388 lines
14 KiB
Python
388 lines
14 KiB
Python
from testlib.fixtures.nix import Nix
|
|
from testlib.fixtures.git import Git
|
|
from testlib.fixtures.file_helper import with_files, File, EnvTemplate
|
|
from testlib.utils import get_global_asset_pack
|
|
from pathlib import Path
|
|
import pytest
|
|
import fnmatch
|
|
import json
|
|
|
|
|
|
@pytest.fixture(autouse=True)
|
|
def add_xp_features(nix: Nix):
|
|
nix.settings.add_xp_feature("nix-command", "flakes")
|
|
|
|
|
|
@with_files(
|
|
{
|
|
"flakeA": get_global_asset_pack(".git")
|
|
| {
|
|
"flake.nix": EnvTemplate("""{
|
|
inputs = {
|
|
B = {
|
|
url = "path:./flakeB";
|
|
inputs.foobar.follows = "foobar";
|
|
};
|
|
foobar.url = "path:@HOME@/flakeA/flakeE";
|
|
};
|
|
outputs = { ... }: {};
|
|
}"""),
|
|
"flakeB": {
|
|
"flake.nix": EnvTemplate("""{
|
|
inputs = {
|
|
foobar.url = "path:@HOME@/flakeA/flakeE";
|
|
goodoo.follows = "C/goodoo";
|
|
C = {
|
|
url = "path:./flakeC";
|
|
inputs.foobar.follows = "foobar";
|
|
};
|
|
};
|
|
outputs = { ... }: {};
|
|
}"""),
|
|
"flakeC": {
|
|
"flake.nix": EnvTemplate("""{
|
|
inputs = {
|
|
foobar.url = "path:@HOME@/flakeA/flakeE";
|
|
goodoo.follows = "foobar";
|
|
};
|
|
outputs = { ... }: {};
|
|
}""")
|
|
},
|
|
},
|
|
"flakeD": {"flake.nix": File("{ outputs = { ... }: {}; }")},
|
|
"flakeE": {"flake.nix": File("{ outputs = { ... }: {}; }")},
|
|
}
|
|
}
|
|
)
|
|
class TestPathFollows:
|
|
@pytest.fixture(autouse=True)
|
|
def init(self, git: Git, files: Path):
|
|
git(files / "flakeA", "add", ".")
|
|
|
|
def test_metadata(self, nix: Nix, files: Path):
|
|
out = nix.nix(["flake", "metadata", files / "flakeA"]).run().ok()
|
|
assert "B: path" in out.stdout_s
|
|
assert "C: path" in out.stdout_s
|
|
assert "foobar: path" in out.stdout_s
|
|
assert "goodoo follows" in out.stdout_s
|
|
|
|
def test_update(self, nix: Nix, files: Path):
|
|
out = nix.nix(["flake", "update", "--flake", files / "flakeA"]).run().ok()
|
|
assert "Added input 'B" in out.stderr_s
|
|
assert "Added input 'B/C" in out.stderr_s
|
|
assert "Added input 'B/C/foobar" in out.stderr_s
|
|
assert "Added input 'B/C/goodoo" in out.stderr_s
|
|
assert "Added input 'B/foobar" in out.stderr_s
|
|
assert "Added input 'B/goodoo" in out.stderr_s
|
|
|
|
def test_lock(self, nix: Nix, files: Path):
|
|
nix.nix(["flake", "lock", files / "flakeA"]).run().ok()
|
|
lockfile = json.loads((files / "flakeA/flake.lock").read_text())
|
|
|
|
assert lockfile["nodes"]["B"]["inputs"]["C"] == "C"
|
|
assert lockfile["nodes"]["B"]["inputs"]["foobar"] == ["foobar"]
|
|
assert lockfile["nodes"]["C"]["inputs"]["foobar"] == ["B", "foobar"]
|
|
|
|
# Ensure that locking twice doesn't change anything
|
|
nix.nix(["flake", "lock", files / "flakeA"]).run().ok()
|
|
lockfile2 = json.loads((files / "flakeA/flake.lock").read_text())
|
|
assert lockfile == lockfile2
|
|
|
|
def test_removing_follows_updates_lockfile(self, nix: Nix, files: Path, git: Git):
|
|
git(files / "flakeA", "add", ".")
|
|
|
|
nix.nix(["flake", "lock", files / "flakeA"]).run().ok()
|
|
(files / "flakeA/flake.nix").write_text("""{
|
|
inputs = {
|
|
B.url = "path:./flakeB";
|
|
D.url = "path:./flakeD";
|
|
};
|
|
outputs = { ... }: {};
|
|
}""")
|
|
|
|
nix.nix(["flake", "lock", files / "flakeA"]).run().ok()
|
|
|
|
lockfile = json.loads((files / "flakeA/flake.lock").read_text())
|
|
assert lockfile["nodes"]["B"]["inputs"]["foobar"] == "foobar"
|
|
assert "foobar" in lockfile["nodes"]
|
|
|
|
|
|
@with_files(
|
|
{
|
|
"flakeA": get_global_asset_pack(".git")
|
|
| {
|
|
"flake.nix": File("""{
|
|
inputs.B.url = "path:../flakeB";
|
|
outputs = { ... }: {};
|
|
}""")
|
|
}
|
|
}
|
|
)
|
|
def test_relative_path_cant_leave_store_path(nix: Nix, files: Path, git: Git):
|
|
git(files / "flakeA", "add", ".")
|
|
|
|
out = nix.nix(["flake", "lock", files / "flakeA"]).run().expect(1)
|
|
assert "points outside" in out.stderr_s
|
|
|
|
|
|
@with_files(
|
|
{
|
|
"flakeA": get_global_asset_pack(".git")
|
|
| {
|
|
"flake.nix": File("""{
|
|
inputs.B = {
|
|
url = "path:./flakeB";
|
|
inputs.invalid.follows = "D";
|
|
inputs.invalid2.url = "path:./flakeD";
|
|
};
|
|
inputs.D.url = "path:./flakeD";
|
|
outputs = { ... }: {};
|
|
}"""),
|
|
"flakeB": {
|
|
"flake.nix": EnvTemplate("""{
|
|
inputs = {
|
|
foobar.url = "path:@HOME@/flakeA/flakeE";
|
|
goodoo.follows = "C/goodoo";
|
|
C = {
|
|
url = "path:./flakeC";
|
|
inputs.foobar.follows = "foobar";
|
|
};
|
|
};
|
|
outputs = { ... }: {};
|
|
}"""),
|
|
"flakeC": {
|
|
"flake.nix": EnvTemplate("""{
|
|
inputs = {
|
|
foobar.url = "path:@HOME@/flakeA/flakeE";
|
|
goodoo.follows = "foobar";
|
|
};
|
|
outputs = { ... }: {};
|
|
}""")
|
|
},
|
|
},
|
|
"flakeD": {"flake.nix": File("{ outputs = { ... }: {}; }")},
|
|
"flakeE": {"flake.nix": File("{ outputs = { ... }: {}; }")},
|
|
}
|
|
}
|
|
)
|
|
def test_nonexistent_follows_print_warnings(nix: Nix, files: Path, git: Git):
|
|
git(files / "flakeA", "add", ".")
|
|
|
|
out = nix.nix(["flake", "lock", files / "flakeA"]).run().ok()
|
|
assert "warning: input 'B' has an override for a non-existent input 'invalid'" in out.stderr_s
|
|
assert "warning: input 'B' has an override for a non-existent input 'invalid2'" in out.stderr_s
|
|
|
|
|
|
@with_files(
|
|
{
|
|
"flakeA": get_global_asset_pack(".git")
|
|
| {
|
|
# input B/D should be able to be found...
|
|
"flake.nix": File("""{
|
|
inputs = {
|
|
B = {
|
|
url = "path:./flakeB";
|
|
inputs.C.follows = "C";
|
|
};
|
|
C.url = "path:./flakeB/flakeC";
|
|
};
|
|
outputs = { ... }: {};
|
|
}"""),
|
|
"flakeB": {
|
|
"flake.nix": File("""{
|
|
inputs = {
|
|
C.url = "path:./flakeC";
|
|
D.follows = "C/D";
|
|
};
|
|
outputs = { ... }: {};
|
|
}"""),
|
|
"flakeC": {
|
|
"flake.nix": File("""{
|
|
inputs.D.url = "path:./flakeD";
|
|
outputs = { ... }: {};
|
|
}"""),
|
|
"flakeD": {"flake.nix": File("{ outputs = { ... }: {}; }")},
|
|
},
|
|
},
|
|
}
|
|
}
|
|
)
|
|
def test_follow_path_overloading(nix: Nix, files: Path, git: Git):
|
|
r"""
|
|
This tests a lockfile checking regression https://github.com/NixOS/nix/pull/8819
|
|
|
|
We construct the following graph, where p->q means p has input q.
|
|
A double edge means that the edge gets overridden using `follows`.
|
|
|
|
A
|
|
/ \
|
|
/ \
|
|
v v
|
|
B ==> C --- follows declared in A
|
|
\\ /
|
|
\\/ --- follows declared in B
|
|
v
|
|
D
|
|
|
|
The message was
|
|
error: input 'B/D' follows a non-existent input 'B/C/D'
|
|
|
|
Note that for `B` to resolve its follow for `D`, it needs `C/D`,
|
|
for which it needs to resolve the follow on `C` first.
|
|
"""
|
|
|
|
git(files / "flakeA", "add", ".")
|
|
|
|
nix.nix(["flake", "metadata", f"{files}/flakeA"]).run().ok()
|
|
nix.nix(["flake", "update", "--flake", f"{files}/flakeA"]).run().ok()
|
|
nix.nix(["flake", "lock", f"{files}/flakeA"]).run().ok()
|
|
|
|
lockfile = json.loads((files / "flakeA/flake.lock").read_text())
|
|
assert lockfile["nodes"]["B"]["inputs"] == {"C": ["C"], "D": ["B", "C", "D"]}
|
|
assert lockfile["nodes"]["C"]["inputs"] == {"D": "D"}
|
|
assert lockfile["nodes"]["root"]["inputs"] == {"B": "B", "C": "C"}
|
|
|
|
|
|
@with_files(
|
|
{
|
|
"flakeA": {
|
|
"flake.nix": EnvTemplate("""{
|
|
inputs.B.url = "path:@HOME@/flakeA/flakeB";
|
|
inputs.D.url = "path:@HOME@/flakeA/flakeD";
|
|
inputs.B.inputs.C.inputs.D.follows = "D";
|
|
outputs = _: {};
|
|
}"""),
|
|
"flakeB": {
|
|
"flake.nix": EnvTemplate("""{
|
|
inputs.C.url = "path:@HOME@/flakeA/flakeB/flakeC";
|
|
outputs = _: {};
|
|
}"""),
|
|
"flakeC": {
|
|
"flake.nix": EnvTemplate("""{
|
|
inputs.D.url = "path:nosuchflake";
|
|
outputs = _: {};
|
|
}""")
|
|
},
|
|
},
|
|
"flakeD": {"flake.nix": File("{ outputs = _: {}; }")},
|
|
}
|
|
}
|
|
)
|
|
def test_nested_overrides(nix: Nix, files: Path):
|
|
nix.nix(["flake", "lock", f"{files}/flakeA"]).run().ok()
|
|
lockfile = json.loads((files / "flakeA/flake.lock").read_text())
|
|
assert lockfile["nodes"]["C"]["inputs"]["D"] == ["D"]
|
|
|
|
|
|
@with_files(
|
|
{
|
|
"flakeA": {
|
|
"flake.nix": EnvTemplate("""{
|
|
inputs.B.url = "path:@HOME@/flakeA/flakeB";
|
|
inputs.C.url = "path:@HOME@/flakeA/flakeB/flakeC";
|
|
inputs.B.inputs.C.follows = "C";
|
|
outputs = _: {};
|
|
}"""),
|
|
"flakeB": {
|
|
"flake.nix": EnvTemplate("""{
|
|
inputs.C.url = "path:nosuchflake";
|
|
inputs.D.url = "path:nosuchflake";
|
|
inputs.D.follows = "C/D";
|
|
outputs = _: {};
|
|
}"""),
|
|
"flakeC": {
|
|
"flake.nix": EnvTemplate("""{
|
|
inputs.D.url = "path:@HOME@/flakeA/flakeD";
|
|
outputs = _: {};
|
|
}""")
|
|
},
|
|
},
|
|
"flakeD": {"flake.nix": File("{ outputs = _: {}; }")},
|
|
}
|
|
}
|
|
)
|
|
def test_overlapping_flake_follows(nix: Nix, files: Path):
|
|
# bug was not triggered without recreating the lockfile
|
|
nix.nix(["flake", "update", "--flake", f"{files}/flakeA"]).run().ok()
|
|
lockfile = json.loads((files / "flakeA/flake.lock").read_text())
|
|
assert lockfile["nodes"]["B"]["inputs"]["D"] == ["B", "C", "D"]
|
|
|
|
|
|
@with_files(
|
|
{
|
|
"flakeA": {
|
|
"flake.nix": EnvTemplate("""{
|
|
inputs.B.url = "path:@HOME@/flakeA/flakeB";
|
|
inputs.C.url = "path:@HOME@/flakeA/flakeB/flakeC";
|
|
inputs.B.inputs.C.inputs.E.follows = "C";
|
|
outputs = _: {};
|
|
}"""),
|
|
"flakeB": {
|
|
"flake.nix": EnvTemplate("""{
|
|
inputs.C.url = "path:@HOME@/flakeA/flakeB/flakeC";
|
|
outputs = _: {};
|
|
}"""),
|
|
"flakeC": {
|
|
"flake.nix": EnvTemplate("""{
|
|
inputs.D.url = "path:@HOME@/flakeA/flakeD";
|
|
outputs = _: {};
|
|
}""")
|
|
},
|
|
},
|
|
"flakeD": {"flake.nix": File("{ outputs = _: {}; }")},
|
|
}
|
|
}
|
|
)
|
|
def test_override_nonexistant_input(nix: Nix, files: Path):
|
|
"""Test overlapping flake follows: B has D follow C/D, while A has B/C follow C"""
|
|
out = nix.nix(["flake", "update", "--flake", f"{files}/flakeA"]).run().ok()
|
|
assert "warning: input 'B/C' has an override for a non-existent input 'E'" in out.stderr_s
|
|
|
|
|
|
@with_files(
|
|
{
|
|
"flakeA": {
|
|
"flake.nix": EnvTemplate("""{
|
|
inputs = {
|
|
B.url = "path:@HOME@/flakeA/flakeB";
|
|
C = {
|
|
url = "path:@HOME@/flakeA/flakeB/flakeC";
|
|
inputs.D.inputs.E.follows = "B";
|
|
};
|
|
};
|
|
outputs = _: {};
|
|
}"""),
|
|
"flakeB": {
|
|
"flake.nix": File("{ outputs = _: {}; }"),
|
|
"flakeC": {
|
|
"flake.nix": EnvTemplate("""{
|
|
inputs.D.url = "path:@HOME@/flakeA/flakeD";
|
|
outputs = _: {};
|
|
}""")
|
|
},
|
|
},
|
|
"flakeD": {
|
|
"flake.nix": File("""{
|
|
inputs.E.url = "path:@HOME@/flakeA/flakeE";
|
|
outputs = _: {};
|
|
}""")
|
|
},
|
|
"flakeE": {"flake.nix": File("{ outputs = { ... }: {}; }")},
|
|
}
|
|
}
|
|
)
|
|
def test_dep_fetch(nix: Nix, files: Path):
|
|
"""Test for Nested follows cause flake interactions to update the nested input #460"""
|
|
|
|
# Lockfiles are cleared, initially the dependency needs to be fetched.
|
|
out = nix.nix(["--verbose", "flake", "show", f"path:{files}/flakeA"]).run().ok()
|
|
assert fnmatch.fnmatch(out.stderr_s, "*\nfetching path input 'path:*/flakeD'\n*")
|
|
|
|
# But on another flake command it doesn't.
|
|
out = nix.nix(["--verbose", "flake", "show", f"path:{files}/flakeA"]).run().ok()
|
|
assert not fnmatch.fnmatch(out.stderr_s, "*\nfetching path input 'path:*/flakeD'\n*")
|
|
|
|
# Make sure the nested override is actually correct in this testcase.
|
|
metadata = nix.nix(["flake", "metadata", f"path:{files}/flakeA", "--json"]).run().json()
|
|
assert metadata["locks"]["nodes"]["D"]["inputs"]["E"] == ["B"]
|