piegamesandeldritch horrors
567348a90c
This commit enables the parametrization for "legacy-combined" protocol. All failing tests with that have been either fixed or disabled. Notably: - A couple of tests (e.g. involving builders) could be made to work with a non-local store, but this would require some refactoring to testlib in order to make certain configuration settings generic over local and remote operations. We've disabled those for now, in order to make progress - The store tests all run locally only because of their nature - The flakes tests also all run locally only because my energy for fixing them is limited (and it's a *lot* of test failures, with probably little overall benefit in terms of test coverage) Change-Id: I56fa249a64f7c17c952f688ec89e9687f2a13f12
923 lines
38 KiB
Python
923 lines
38 KiB
Python
from fnmatch import fnmatch
|
|
from pathlib import Path
|
|
from textwrap import dedent
|
|
import pytest
|
|
import re
|
|
import tarfile
|
|
import json
|
|
import shutil
|
|
|
|
from testlib.fixtures.nix import Nix
|
|
from testlib.fixtures.env import ManagedEnv
|
|
from testlib.fixtures.git import Git
|
|
from testlib.utils import get_global_asset_pack, get_global_asset
|
|
from testlib.fixtures.file_helper import with_files, File, FileDeclaration, _init_files # noqa: PLC2701
|
|
from testlib.environ import environ
|
|
from .common import simple_flake, dependent_flake
|
|
|
|
pytestmark = pytest.mark.no_daemon
|
|
|
|
system = environ.get("system")
|
|
|
|
|
|
def dotgit_other_branch() -> FileDeclaration:
|
|
result = get_global_asset_pack(".git")
|
|
result[".git"]["HEAD"] = File("ref: refs/heads/other-branch")
|
|
return result
|
|
|
|
|
|
@pytest.fixture(autouse=True)
|
|
def setup_env(nix: Nix):
|
|
nix.settings.add_xp_feature("nix-command", "flakes")
|
|
|
|
|
|
flake1_files = {"flake1": get_global_asset_pack(".git") | simple_flake()}
|
|
flake2_files = {
|
|
"flake2": dotgit_other_branch()
|
|
| {
|
|
"flake.nix": File(f"""{{
|
|
description = "Fnord";
|
|
|
|
outputs = {{ self, flake1 }}: rec {{
|
|
packages.{system}.bar = flake1.packages.{system}.foo;
|
|
}};
|
|
}}""")
|
|
}
|
|
}
|
|
flake3_files = {
|
|
"flake3": get_global_asset_pack(".git")
|
|
| {
|
|
"flake.nix": File(f"""{{
|
|
description = "Fnord";
|
|
|
|
outputs = {{ self, flake2 }}: rec {{
|
|
packages.{system}.xyzzy = flake2.packages.{system}.bar;
|
|
|
|
checks.xyzzy = packages.{system}.xyzzy;
|
|
}};
|
|
}}"""),
|
|
"default.nix": File("{ x = 123; }"),
|
|
}
|
|
}
|
|
flake5_files = {"flake5": dependent_flake()}
|
|
flake7_files = {
|
|
"flake7": get_global_asset_pack(".git")
|
|
| {"flake.nix": File("{ outputs = { self }: { expr = 123; }; }")}
|
|
}
|
|
nonflake_files = {"nonFlake": get_global_asset_pack(".git") | {"README.md": File("FNORD")}}
|
|
|
|
|
|
def _make_flake_repo(
|
|
name: str, files: FileDeclaration, git: Git, env: ManagedEnv, request: pytest.FixtureRequest
|
|
) -> Path:
|
|
_init_files(files, env.dirs.test_root, request.path.parent, env)
|
|
repo = env.dirs.test_root / name
|
|
git(repo, "add", ".")
|
|
git(repo, "commit", "-m", "Initial")
|
|
return repo
|
|
|
|
|
|
@pytest.fixture
|
|
def flake1(git: Git, env: ManagedEnv, request: pytest.FixtureRequest) -> Path:
|
|
return _make_flake_repo("flake1", flake1_files, git, env, request)
|
|
|
|
|
|
def _modify_flake1(flake1: Path, git: Git | None):
|
|
(flake1 / "foo").write_text("foo")
|
|
(flake1 / "flake.nix").write_text((flake1 / "flake.nix").read_text() + "# foo")
|
|
if git is not None:
|
|
git(flake1, "add", "foo")
|
|
git(flake1, "commit", "-a", "-m", "Foo")
|
|
|
|
|
|
@pytest.fixture
|
|
def flake2(git: Git, env: ManagedEnv, request: pytest.FixtureRequest) -> Path:
|
|
return _make_flake_repo("flake2", flake2_files, git, env, request)
|
|
|
|
|
|
@pytest.fixture
|
|
def flake3(git: Git, env: ManagedEnv, request: pytest.FixtureRequest) -> Path:
|
|
return _make_flake_repo("flake3", flake3_files, git, env, request)
|
|
|
|
|
|
@pytest.fixture
|
|
def flake3_locked(git: Git, env: ManagedEnv, nix: Nix, flake3: Path, nonflake: Path) -> Path: # noqa: ARG001
|
|
nix.nix(["flake", "lock", flake3, "--commit-lock-file"]).run().ok()
|
|
return flake3
|
|
|
|
|
|
@pytest.fixture
|
|
def flake3_medium(git: Git, env: ManagedEnv, nix: Nix, flake3: Path, nonflake: Path) -> Path: # noqa: ARG001
|
|
(flake3 / "flake.nix").write_text(f"""{{
|
|
inputs = {{
|
|
nonFlake = {{
|
|
url = "{env.dirs.test_root}/nonFlake";
|
|
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
|
|
'';
|
|
}};
|
|
}};
|
|
}}""")
|
|
nix.nix(["flake", "lock", flake3]).run().ok()
|
|
git(flake3, "add", "flake.nix", "flake.lock")
|
|
git(flake3, "commit", "-m", "medium config")
|
|
return flake3
|
|
|
|
|
|
@pytest.fixture
|
|
def flake5(env: ManagedEnv, request: pytest.FixtureRequest) -> Path:
|
|
_init_files(flake5_files, env.dirs.test_root, request.path.parent, env)
|
|
return env.dirs.test_root / "flake5"
|
|
|
|
|
|
@pytest.fixture
|
|
def flake5_locked_tarball(env: ManagedEnv, flake5: Path, nix: Nix) -> Path:
|
|
nix.nix(["flake", "lock", flake5]).run().ok()
|
|
path = env.dirs.test_root / "flake5.tar.gz"
|
|
with tarfile.open(path, "w:gz") as tar:
|
|
tar.add(flake5, "flake5")
|
|
return path
|
|
|
|
|
|
@pytest.fixture
|
|
def flake7(git: Git, env: ManagedEnv, request: pytest.FixtureRequest) -> Path:
|
|
return _make_flake_repo("flake7", flake7_files, git, env, request)
|
|
|
|
|
|
@pytest.fixture
|
|
def nonflake(git: Git, env: ManagedEnv, request: pytest.FixtureRequest) -> Path:
|
|
_init_files(nonflake_files, env.dirs.test_root, request.path.parent, env)
|
|
repo = env.dirs.test_root / "nonFlake"
|
|
git(repo, "add", ".")
|
|
git(repo, "commit", "-m", "Initial")
|
|
return repo
|
|
|
|
|
|
@pytest.fixture
|
|
def registry(nix: Nix, flake1: Path, flake2: Path, flake3: Path) -> Path:
|
|
registry = nix.env.dirs.test_root / "registry.json"
|
|
nix.settings.flake_registry = str(registry)
|
|
|
|
# Construct a custom registry, additionally test the --registry flag
|
|
nix.nix(
|
|
["registry", "add", "--registry", registry, "flake1", f"git+file://{flake1}"]
|
|
).run().ok()
|
|
nix.nix(
|
|
["registry", "add", "--registry", registry, "flake2", f"git+file://{flake2}"]
|
|
).run().ok()
|
|
nix.nix(
|
|
["registry", "add", "--registry", registry, "flake3", f"git+file://{flake3}"]
|
|
).run().ok()
|
|
nix.nix(["registry", "add", "--registry", registry, "flake4", "flake3"]).run().ok()
|
|
nix.nix(["registry", "add", "--registry", registry, "nixpkgs", "flake1"]).run().ok()
|
|
|
|
return registry
|
|
|
|
|
|
@pytest.mark.usefixtures("registry")
|
|
class TestAttrMatch:
|
|
def test_fuzzy_plain(self, nix: Nix):
|
|
logs = nix.nix(["eval", "flake1#ERROR"]).run().expect(1).stderr_s
|
|
assert re.search(r"error:.*does not provide attribute.*or 'ERROR'$", logs)
|
|
|
|
def test_exact_plain(self, nix: Nix):
|
|
logs = nix.nix(["eval", "flake1#.ERROR"]).run().expect(1).stderr_s
|
|
assert re.search(r"error:.*does not provide attribute 'ERROR'$", logs)
|
|
|
|
def test_fuzzy_branch(self, nix: Nix):
|
|
path = nix.nix(["eval", "flake1/main#foo"]).run().ok().stdout_s
|
|
assert "-simple.drv" in path
|
|
|
|
class TestRegistryBranch:
|
|
@pytest.fixture(autouse=True)
|
|
def create_other_branch(self, flake1: Path, git: Git):
|
|
git(flake1, "checkout", "-b", "other")
|
|
(flake1 / "flake.nix").write_text(
|
|
(flake1 / "flake.nix").read_text().replace("foo", "bar")
|
|
)
|
|
git(flake1, "commit", "-a", "-mrename foo -> bar")
|
|
git(flake1, "checkout", "main")
|
|
|
|
def test_fuzzy_main_branch(self, nix: Nix):
|
|
assert (
|
|
"flake 'flake:flake1/main' does not provide attribute"
|
|
in nix.nix(["eval", "flake1/main#bar"]).run().expect(1).stderr_s
|
|
)
|
|
path = nix.nix(["eval", "flake1/main#foo"]).run().ok().stdout_s
|
|
assert "-simple.drv" in path
|
|
|
|
def test_fuzzy_other_branch(self, nix: Nix):
|
|
assert (
|
|
"flake 'flake:flake1/other' does not provide attribute"
|
|
in nix.nix(["eval", "flake1/other#foo"]).run().expect(1).stderr_s
|
|
)
|
|
path = nix.nix(["eval", "flake1/other#bar"]).run().ok().stdout_s
|
|
assert "-simple.drv" in path
|
|
|
|
|
|
def test_eval_system_takes_effect(nix: Nix, flake1: Path):
|
|
(flake1 / "flake.nix").write_text(
|
|
(flake1 / "flake.nix").read_text().replace(system, "kitty-kitty")
|
|
)
|
|
nix.nix(["build", "--eval-system", "kitty-kitty", flake1]).run().ok()
|
|
|
|
|
|
class TestGetFlake:
|
|
def test_unlocked_pure_fails(self, nix: Nix, flake1: Path):
|
|
expr = f'(builtins.getFlake "{flake1}").packages.{system}.default'
|
|
result = nix.nix(["build", "--expr", expr]).run().expect(1)
|
|
assert "error: cannot call 'getFlake' on unlocked flake reference" in result.stderr_s
|
|
|
|
def test_unlocked_impure_works(self, nix: Nix, flake1: Path):
|
|
expr = f'(builtins.getFlake "{flake1}").packages.{system}.default'
|
|
nix.nix(["build", "--impure", "--expr", expr]).run().ok()
|
|
assert (Path(nix.env.dirs.home / "result/hello")).exists()
|
|
|
|
def test_locked_url_pure_works(self, nix: Nix, flake1: Path, git: Git):
|
|
flake1_original_commit = git(flake1, "rev-parse", "HEAD").stdout_s.strip()
|
|
expr = f'(builtins.getFlake "git+file://{flake1}?rev={flake1_original_commit}").packages.{system}.default'
|
|
nix.nix(["build", "--expr", expr]).run().ok()
|
|
assert (Path(nix.env.dirs.home / "result/hello")).exists()
|
|
|
|
def test_unlocked_dep_pure_fails(self, nix: Nix, flake2: Path):
|
|
# NOTE: this is the same test as test_unlocked_dep_pure_fails because flake2 is not locked,
|
|
# and flake2 *cannot* be locked because that would also lock flake1 in the flake2 lock file
|
|
nix.nix(["eval", "--expr", f'(builtins.getFlake "{flake2}")']).run().expect(1)
|
|
|
|
@pytest.mark.usefixtures("registry")
|
|
def test_unlocked_dep_impure_works(self, nix: Nix, flake2: Path):
|
|
# NOTE: see test above, same thing happens here
|
|
nix.nix(["eval", "--impure", "--expr", f'(builtins.getFlake "{flake2}")']).run().ok()
|
|
|
|
|
|
@pytest.mark.usefixtures("registry")
|
|
class TestRegistry:
|
|
def test_registry_list(self, nix: Nix):
|
|
result = nix.nix(["registry", "list"]).run().ok().stdout_s
|
|
assert len(result.splitlines()) == 5
|
|
assert re.search(r"^global", result, re.M)
|
|
assert not re.search(r"^user", result, re.M) # nothing in user registry
|
|
|
|
def test_registry_caching(self, nix: Nix, registry: Path):
|
|
result = (
|
|
nix.nix(["registry", "list", "--flake-registry", f"file://{registry}"])
|
|
.run()
|
|
.ok()
|
|
.stdout_s
|
|
)
|
|
assert "flake3" in result
|
|
registry.unlink()
|
|
nix.nix(["store", "gc"]).run().ok()
|
|
result = (
|
|
nix.nix(["registry", "list", "--flake-registry", f"file://{registry}"])
|
|
.run()
|
|
.ok()
|
|
.stdout_s
|
|
)
|
|
assert "flake3" in result
|
|
|
|
class TestCLI:
|
|
def test_add(self, nix: Nix):
|
|
nix.nix(["registry", "add", "flake1", "flake3"]).run().ok()
|
|
result = nix.nix(["registry", "list"]).run().ok().stdout_s
|
|
assert len(result.splitlines()) == 6
|
|
assert re.search(r"^global", result, re.M)
|
|
assert re.search(r"^user", result, re.M) # something in user registry now
|
|
|
|
def test_pin_rev(self, nix: Nix, flake1: Path, git: Git):
|
|
commit = git(flake1, "rev-parse", "HEAD").stdout_s.strip()
|
|
nix.nix(["registry", "pin", "flake1"]).run().ok()
|
|
result = nix.nix(["registry", "list"]).run().ok().stdout_s
|
|
assert f"flake1?ref=refs/heads/main&rev={commit}" in result
|
|
|
|
def test_pin_to_other(self, nix: Nix, flake3: Path, git: Git):
|
|
commit = git(flake3, "rev-parse", "HEAD").stdout_s.strip()
|
|
nix.nix(["registry", "pin", "flake1", "flake3"]).run().ok()
|
|
result = nix.nix(["registry", "list"]).run().ok().stdout_s
|
|
assert f"flake3?ref=refs/heads/main&rev={commit}" in result
|
|
|
|
def test_add_remove(self, nix: Nix):
|
|
nix.nix(["registry", "add", "flake1", "flake3"]).run().ok()
|
|
nix.nix(["registry", "remove", "flake1"]).run().ok()
|
|
result = nix.nix(["registry", "list"]).run().ok().stdout_s
|
|
assert len(result.splitlines()) == 5
|
|
assert re.search(r"^global", result, re.M)
|
|
assert not re.search(r"^user", result, re.M) # nothing in user registry
|
|
|
|
class TestShorthands:
|
|
"""
|
|
'nix registry add' should accept flake shorthands (with or without branch or rev)
|
|
in the from argument, but reject fully-qualified from-urls (direct or indirect).
|
|
"""
|
|
|
|
def test_plain(self, nix: Nix):
|
|
nix.nix(["registry", "add", "nixpkgz", "github:NixOS/nixpkgz"]).run().ok()
|
|
assert "user flake:nixpkgz" in nix.nix(["registry", "list"]).run().ok().stdout_s
|
|
nix.nix(["registry", "remove", "nixpkgz"]).run().ok()
|
|
assert (
|
|
"user flake:nixpkgz" not in nix.nix(["registry", "list"]).run().ok().stdout_s
|
|
)
|
|
|
|
def test_branch(self, nix: Nix):
|
|
nix.nix(["registry", "add", "nixpkgz/branch", "github:NixOS/nixpkgz"]).run().ok()
|
|
assert (
|
|
"user flake:nixpkgz/branch"
|
|
in nix.nix(["registry", "list"]).run().ok().stdout_s
|
|
)
|
|
nix.nix(["registry", "remove", "nixpkgz/branch"]).run().ok()
|
|
assert (
|
|
"user flake:nixpkgz/branch"
|
|
not in nix.nix(["registry", "list"]).run().ok().stdout_s
|
|
)
|
|
|
|
def test_branch_rev(self, nix: Nix):
|
|
ref = "nixpkgz/branch/1db42b7fe3878f3f5f7a4f2dc210772fd080e205"
|
|
nix.nix(["registry", "add", ref, "github:NixOS/nixpkgz"]).run().ok()
|
|
assert f"user flake:{ref}" in nix.nix(["registry", "list"]).run().ok().stdout_s
|
|
nix.nix(["registry", "remove", ref]).run().ok()
|
|
assert (
|
|
f"user flake:{ref}" not in nix.nix(["registry", "list"]).run().ok().stdout_s
|
|
)
|
|
|
|
def test_rejects_qualified(self, nix: Nix):
|
|
assert (
|
|
"error: 'from-url' argument must be a shorthand"
|
|
in nix.nix(["registry", "add", "flake:nixpkgz", "github:NixOS/nixpkgz"])
|
|
.run()
|
|
.expect(1)
|
|
.stderr_s
|
|
)
|
|
assert (
|
|
"error: 'from-url' argument must be a shorthand"
|
|
in nix.nix(["registry", "add", "github:NixOS/nixpkgz", "github:NixOS/nixpkgz"])
|
|
.run()
|
|
.expect(1)
|
|
.stderr_s
|
|
)
|
|
|
|
def test_disabled_global_registry(self, nix: Nix, flake1: Path, flake2: Path):
|
|
nix.nix(["registry", "add", "user-flake1", f"git+file://{flake1}"]).run().ok()
|
|
nix.nix(["registry", "add", "user-flake2", f"git+file://{flake2}"]).run().ok()
|
|
|
|
result = nix.nix(["--flake-registry", "", "registry", "list"]).run().ok().stdout_s
|
|
assert len(result.splitlines()) == 2
|
|
assert not re.search(r"^global", result, re.M) # nothing in global registry
|
|
assert re.search(r"^user", result, re.M)
|
|
|
|
|
|
@pytest.mark.usefixtures("registry")
|
|
class TestBuild:
|
|
def test_build_attr(self, nix: Nix):
|
|
nix.nix(["build", "flake1#foo"]).run().ok()
|
|
assert (nix.env.dirs.home / "result/hello").exists()
|
|
|
|
def test_build_without_attr_registry(self, nix: Nix):
|
|
nix.nix(["build", "flake1"]).run().ok()
|
|
assert (nix.env.dirs.home / "result/hello").exists()
|
|
|
|
@pytest.mark.parametrize("scheme", ["", "git+file://"])
|
|
def test_build_without_attr_url(self, nix: Nix, flake1: Path, scheme: str):
|
|
nix.nix(["build", f"{scheme}{flake1}"]).run().ok()
|
|
assert (nix.env.dirs.home / "result/hello").exists()
|
|
|
|
@pytest.mark.parametrize("arg", ["--no-registries", "--no-use-registries"])
|
|
def test_pure_build_unlocked_deps_failure(self, nix: Nix, arg: str):
|
|
result = nix.nix(["build", "flake2#bar", arg]).run().expect(1).stderr_s
|
|
assert (
|
|
"error: 'flake:flake2' is an indirect flake reference, but registry lookups are not allowed"
|
|
in result
|
|
)
|
|
|
|
def test_impure_build_unlocked_deps_fails(self, nix: Nix):
|
|
result = nix.nix(["build", "flake2#bar", "--impure"]).run().expect(1).stderr_s
|
|
assert "error: cannot write modified lock file" in result
|
|
|
|
def test_impure_build_unlocked_deps_succeeds_with_no_write(self, nix: Nix):
|
|
logs = (
|
|
nix.nix(["build", "flake2#bar", "--impure", "--no-write-lock-file"]).run().ok().stderr_s
|
|
)
|
|
assert re.search(r"building '.*-simple.drv'", logs)
|
|
|
|
def test_build_unlocked_fails_with_no_update(self, nix: Nix, flake2: Path):
|
|
logs = nix.nix(["build", f"{flake2}#bar", "--no-update-lock-file"]).run().expect(1).stderr_s
|
|
assert "requires lock file changes" in logs
|
|
|
|
def test_build_unlocked_succeeds_with_no_write(self, nix: Nix):
|
|
logs = nix.nix(["build", "flake2#bar", "--no-write-lock-file"]).run().ok().stderr_s
|
|
assert re.search(r"building '.*-simple.drv'", logs)
|
|
|
|
class TestLockedFlake2:
|
|
@pytest.fixture(autouse=True)
|
|
def lock_flake2(self, nix: Nix, flake2: Path, registry: Path): # noqa: ARG002
|
|
nix.nix(["flake", "lock", flake2, "--commit-lock-file"]).run().ok()
|
|
|
|
def test_setup_did_commit(self, flake2: Path, git: Git):
|
|
assert (flake2 / "flake.lock").exists()
|
|
assert not git(flake2, "diff", "HEAD").stdout_s
|
|
|
|
def test_rerunning_builds_does_not_change_lockfile(self, nix: Nix, flake2: Path, git: Git):
|
|
nix.nix(["build", f"{flake2}#bar", "--no-write-lock-file"]).run().ok()
|
|
assert not git(flake2, "diff", "HEAD").stdout_s
|
|
|
|
@pytest.mark.parametrize(
|
|
"args",
|
|
[
|
|
["--flake-registry", "file:///no-registry.json", "--refresh"],
|
|
["--no-registries", "--refresh"],
|
|
["--no-use-registries", "--refresh"],
|
|
[],
|
|
],
|
|
)
|
|
@pytest.mark.parametrize("scheme", ["", "git+file://"])
|
|
def test_locked_build_works(self, nix: Nix, flake2: Path, args: list[str], scheme: str):
|
|
# registry fetches are not logged anywhere!
|
|
nix.nix(["build", *args, f"{scheme}{flake2}#bar"]).run().ok()
|
|
|
|
def test_lock_idempotent(self, nix: Nix, flake2: Path, git: Git):
|
|
nix.nix(["flake", "lock", flake2]).run().ok()
|
|
assert not git(flake2, "diff", "HEAD").stdout_s
|
|
|
|
def test_indirect_dependencies(self, nix: Nix, flake3: Path):
|
|
logs = nix.nix(["build", f"{flake3}#xyzzy"]).run().ok().stderr_s
|
|
assert "Added input 'flake2'" in logs
|
|
assert "Added input 'flake2/flake1'" in logs
|
|
assert re.search(r"building '.*-simple.drv'", logs)
|
|
|
|
def test_bare_repo(self, nix: Nix, flake1: Path, git: Git):
|
|
git(None, "clone", "--bare", flake1, "bare")
|
|
logs = nix.nix(["build", f"git+file://{nix.env.dirs.home}/bare"]).run().ok().stderr_s
|
|
assert re.search(r"building '.*-simple.drv'", logs)
|
|
|
|
def test_tarball(self, nix: Nix, flake5_locked_tarball: Path):
|
|
logs = nix.nix(["build", f"file://{flake5_locked_tarball}"]).run().ok().stderr_s
|
|
assert "fetching tarball input" in logs
|
|
assert re.search(r"building '.*-simple.drv'", logs)
|
|
|
|
def test_tarball_with_sri(self, nix: Nix, flake5_locked_tarball: Path):
|
|
# lockfile contains absolute references to test data, hash can't be deterministic
|
|
url = (
|
|
nix.nix(["flake", "metadata", "--json", f"file://{flake5_locked_tarball}"])
|
|
.run()
|
|
.json()["url"]
|
|
)
|
|
assert "sha256-" in url
|
|
|
|
nix.clear_store()
|
|
|
|
logs = nix.nix(["build", url]).run().ok().stderr_s
|
|
assert "fetching tarball input" in logs
|
|
assert re.search(r"building '.*-simple.drv'", logs)
|
|
|
|
def test_tarball_bad_sri(self, nix: Nix, flake5_locked_tarball: Path):
|
|
url = f"file://{flake5_locked_tarball}?narHash=sha256-qQ2Zz4DNHViCUrp6gTS7EE4+RMqFQtUfWF2UNUtJKS0="
|
|
logs = nix.nix(["build", url]).run().expect(102).stderr_s
|
|
assert "NAR hash mismatch" in logs
|
|
|
|
class TestIncompleteLockfile:
|
|
@pytest.fixture(autouse=True)
|
|
def update_flake(self, nix: Nix, flake3: Path, git: Git, registry: Path): # noqa: ARG002
|
|
nix.nix(["flake", "lock", flake3]).run().ok()
|
|
git(flake3, "add", "flake.lock")
|
|
(flake3 / "flake.nix").write_text(f"""{{
|
|
outputs = {{ self, flake1, flake2 }}: rec {{
|
|
packages.{system}.xyzzy = flake2.packages.{system}.bar;
|
|
packages.{system}."sth sth" = flake1.packages.{system}.foo;
|
|
}};
|
|
}}""")
|
|
git(flake3, "add", "flake.nix")
|
|
git(flake3, "commit", "-m", "Update flake.nix")
|
|
|
|
@pytest.mark.parametrize("attr", ["sth sth", "sth%20sth"])
|
|
def test_build(self, nix: Nix, flake3: Path, git: Git, attr: str):
|
|
nix.nix(["build", f"{flake3}#{attr}"]).run().ok()
|
|
|
|
# check that the lockfile was changed
|
|
assert git(flake3, "diff", "HEAD").stdout_s
|
|
|
|
def test_deep_build(self, nix: Nix, flake3: Path):
|
|
"""test builds that need recursive flakeref resolution"""
|
|
# flake4 points to flake3 which thus needs locked
|
|
nix.nix(["flake", "lock", flake3]).run().ok()
|
|
nix.nix(["build", "flake4#xyzzy"]).run().ok()
|
|
|
|
|
|
@with_files({"config.nix": get_global_asset("config.nix")})
|
|
@pytest.mark.usefixtures("registry")
|
|
class TestWithNonFlake:
|
|
@pytest.fixture(autouse=True)
|
|
def add_nonflake(self, flake3: Path, nonflake: Path, git: Git, files: Path):
|
|
(flake3 / "flake.nix").write_text(f"""{{
|
|
inputs = {{
|
|
flake1 = {{}};
|
|
flake2 = {{}};
|
|
nonFlake = {{
|
|
url = "git+file://{nonflake}";
|
|
flake = false;
|
|
}};
|
|
nonFlakeFile = {{
|
|
url = "path://{nonflake}/README.md";
|
|
flake = false;
|
|
}};
|
|
nonFlakeFile2 = {{
|
|
url = "{nonflake}/README.md";
|
|
flake = false;
|
|
}};
|
|
}};
|
|
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}} ]]
|
|
'';
|
|
}};
|
|
}};
|
|
}}""")
|
|
(flake3 / "config.nix").write_text((files / "config.nix").read_text())
|
|
git(flake3, "add", "flake.nix", "config.nix")
|
|
git(flake3, "commit", "-m", "Add nonFlakeInputs")
|
|
|
|
def test_flake_lock_updates(self, nix: Nix, flake3: Path, git: Git):
|
|
nix.nix(["build", f"{flake3}#sth", "--commit-lock-file"]).run().ok()
|
|
msg = git(flake3, "show", "-s", "--format=format:%B").stdout_s
|
|
assert fnmatch(
|
|
msg,
|
|
dedent("""\
|
|
flake.lock: Add
|
|
|
|
Flake lock file updates:
|
|
|
|
• Added input 'flake1':
|
|
'git+file://*/flake1[?]ref=refs/heads/main&rev=*' *
|
|
• Added input 'nonFlake':
|
|
'git+file://*/nonFlake[?]ref=refs/heads/main&rev=*' *
|
|
• Added input 'nonFlakeFile':
|
|
'path:*/nonFlake/README.md[?]lastModified=*&narHash=sha256-W9JwWKcSn1bi98dD6XPmDM3cDkXXPK%2B9tLkPhjxAHyg%3D' *
|
|
• Added input 'nonFlakeFile2':
|
|
'path:*/nonFlake/README.md[?]lastModified=*&narHash=sha256-W9JwWKcSn1bi98dD6XPmDM3cDkXXPK%2B9tLkPhjxAHyg%3D' *"""),
|
|
)
|
|
|
|
def test_build_nonflake(self, nix: Nix, flake3: Path):
|
|
nix.nix(["build", f"{flake3}#fnord"]).run().ok()
|
|
assert (nix.env.dirs.home / "result").read_text() == "FNORD"
|
|
|
|
class TestFetchIsLazy:
|
|
"""
|
|
Check whether flake input fetching is lazy: flake3#sth does not
|
|
depend on flake2, so this shouldn't fail.
|
|
"""
|
|
|
|
@pytest.fixture(autouse=True)
|
|
def clear_state(
|
|
self,
|
|
nix: Nix,
|
|
registry: Path, # noqa: ARG002
|
|
flake2: Path, # noqa: ARG002
|
|
flake3_locked: Path, # noqa: ARG002
|
|
nonflake: Path, # noqa: ARG002
|
|
):
|
|
shutil.rmtree(nix.env.dirs.home / ".cache")
|
|
nix.clear_store()
|
|
|
|
def test_deps_not_fetched_unless_needed(self, nix: Nix, flake2: Path, nonflake: Path):
|
|
shutil.rmtree(flake2)
|
|
shutil.rmtree(nonflake)
|
|
|
|
nix.nix(["build", "flake3#sth"]).run().ok()
|
|
|
|
def test_dep_fetches_fail_builds(self, nix: Nix, flake2: Path, nonflake: Path):
|
|
shutil.rmtree(flake2)
|
|
shutil.rmtree(nonflake)
|
|
result = nix.nix(["build", "flake3#xyzzy"]).run().expect(1).stderr_s
|
|
assert fnmatch(result, "*while fetching the input '*/flake2*'*")
|
|
result = nix.nix(["build", "flake3#fnord"]).run().expect(1).stderr_s
|
|
assert fnmatch(result, "*while fetching the input '*/nonFlake*'*")
|
|
|
|
def test_deps_fetched_when_present(self, nix: Nix):
|
|
nix.nix(["build", "flake3#sth"]).run().ok()
|
|
nix.nix(["build", "flake3#xyzzy", "flake3#fnord"]).run().ok()
|
|
|
|
|
|
@pytest.mark.usefixtures("registry")
|
|
def test_update_with_override_flake(nix: Nix, flake3: Path, git: Git):
|
|
nix.nix(
|
|
["flake", "update", "--flake", flake3, "--override-input", "flake2", "nixpkgs"]
|
|
).run().ok()
|
|
assert git(flake3, "diff", "HEAD").stdout_s
|
|
|
|
|
|
def test_symlinks_in_flakes_are_not_flakes(nix: Nix, flake1: Path):
|
|
nix.nix(["build", "-o", flake1 / "result", f"git+file://{flake1}"]).run().ok()
|
|
nix.nix(["path-info", flake1 / "result"]).run().ok()
|
|
|
|
|
|
@pytest.mark.usefixtures("registry")
|
|
def test_flakes_gcroots(nix: Nix, flake1: Path, flake2: Path):
|
|
"""
|
|
Test whether flakes are registered as GC roots for offline use.
|
|
FIXME(ancient): use tarballs rather than git.
|
|
"""
|
|
|
|
nix.env["_NIX_FORCE_HTTP"] = "1"
|
|
shutil.rmtree(nix.env.dirs.home / ".cache")
|
|
nix.clear_store() # absolutely make sure the store is empty first
|
|
|
|
nix.nix(["flake", "lock", flake2, "--commit-lock-file"]).run().ok()
|
|
nix.nix(["build", f"git+file://{flake2}#bar"]).run().ok()
|
|
|
|
shutil.rmtree(flake1)
|
|
shutil.rmtree(flake2)
|
|
|
|
nix.nix(["store", "gc"]).run().ok()
|
|
|
|
nix.nix(["build", f"git+file://{flake2}#bar"]).run().ok()
|
|
nix.nix(["build", f"git+file://{flake2}#bar", "--refresh"]).run().ok()
|
|
|
|
|
|
@pytest.mark.usefixtures("registry")
|
|
def test_flake_clone(nix: Nix):
|
|
dest = nix.env.dirs.home / "flake1-v2"
|
|
nix.nix(["flake", "clone", "flake1", "--dest", dest]).run().ok()
|
|
assert (dest / "flake.nix").exists()
|
|
|
|
|
|
@pytest.mark.usefixtures("registry")
|
|
class TestLock:
|
|
def test_path_url(self, nix: Nix, flake5: Path):
|
|
logs = nix.nix(["flake", "lock", f"path://{flake5}"]).run().ok().stderr_s
|
|
assert "Added input 'flake1'" in logs
|
|
assert f"fetching path input 'path:{flake5}" in logs
|
|
|
|
def test_override_inputs(
|
|
self, nix: Nix, flake1: Path, flake3: Path, flake5_locked_tarball: Path, git: Git
|
|
):
|
|
# this is one big test due to necessary state changes, 🐻 with me
|
|
flake1_original_commit = git(flake1, "rev-parse", "HEAD").stdout_s.strip()
|
|
|
|
url = f"file://{flake5_locked_tarball}"
|
|
nix.nix(["flake", "lock", flake3, "--override-input", "flake2/flake1", url]).run().ok()
|
|
lock = json.loads((flake3 / "flake.lock").read_text())
|
|
assert lock["nodes"]["flake1"]["locked"]["url"] == url
|
|
|
|
nix.nix(["flake", "lock", flake3, "--override-input", "flake2/flake1", "flake1"]).run().ok()
|
|
lock = json.loads((flake3 / "flake.lock").read_text())
|
|
assert lock["nodes"]["flake1"]["locked"]["rev"] == flake1_original_commit
|
|
|
|
git(flake1, "checkout", "-b", "other")
|
|
_modify_flake1(flake1, git)
|
|
other_hash = git(flake1, "rev-parse", "HEAD").stdout_s.strip()
|
|
git(flake1, "checkout", "main")
|
|
|
|
ref = f"flake1/other/{other_hash}"
|
|
nix.nix(["flake", "lock", flake3, "--override-input", "flake2/flake1", ref]).run().ok()
|
|
lock = json.loads((flake3 / "flake.lock").read_text())
|
|
assert lock["nodes"]["flake1"]["locked"]["rev"] == other_hash
|
|
|
|
nix.nix(["flake", "lock", flake3]).run().ok()
|
|
lock = json.loads((flake3 / "flake.lock").read_text())
|
|
assert lock["nodes"]["flake1"]["locked"]["rev"] == other_hash
|
|
|
|
def test_update_individual_input(self, nix: Nix, flake1: Path, flake3_medium: Path, git: Git):
|
|
flake1_original_commit = git(flake1, "rev-parse", "HEAD").stdout_s.strip()
|
|
_modify_flake1(flake1, git)
|
|
flake1_modified_commit = git(flake1, "rev-parse", "HEAD").stdout_s.strip()
|
|
|
|
nix.nix(["flake", "update", "flake2/flake1", "--flake", flake3_medium]).run().ok()
|
|
lock = json.loads((flake3_medium / "flake.lock").read_text())
|
|
assert lock["nodes"]["flake1"]["locked"]["rev"] == flake1_original_commit
|
|
assert lock["nodes"]["flake1_2"]["locked"]["rev"] == flake1_modified_commit
|
|
|
|
def test_update_multiple_inputs(self, nix: Nix, flake1: Path, flake3_medium: Path, git: Git):
|
|
_modify_flake1(flake1, git)
|
|
flake1_modified_commit = git(flake1, "rev-parse", "HEAD").stdout_s.strip()
|
|
|
|
nix.nix(["flake", "update", "flake1", "flake2/flake1", "--flake", flake3_medium]).run().ok()
|
|
lock = json.loads((flake3_medium / "flake.lock").read_text())
|
|
assert lock["nodes"]["flake1"]["locked"]["rev"] == flake1_modified_commit
|
|
assert lock["nodes"]["flake1_2"]["locked"]["rev"] == flake1_modified_commit
|
|
|
|
class TestFollows:
|
|
def test_simple_explicit(self, nix: Nix, flake3: Path):
|
|
(flake3 / "flake.nix").write_text("""{
|
|
inputs.foo = {
|
|
type = "indirect";
|
|
id = "flake1";
|
|
};
|
|
inputs.bar.follows = "foo";
|
|
|
|
outputs = { self, foo, bar }: {};
|
|
}""")
|
|
nix.nix(["flake", "lock", flake3]).run().ok()
|
|
lock = json.loads((flake3 / "flake.lock").read_text())
|
|
assert lock["nodes"]["root"]["inputs"]["bar"] == ["foo"]
|
|
|
|
def test_nested_implicit(self, nix: Nix, flake3: Path):
|
|
(flake3 / "flake.nix").write_text("""{
|
|
inputs.bar.follows = "flake2/flake1";
|
|
|
|
outputs = { self, flake2, bar }: {};
|
|
}""")
|
|
nix.nix(["flake", "lock", flake3]).run().ok()
|
|
lock = json.loads((flake3 / "flake.lock").read_text())
|
|
assert lock["nodes"]["root"]["inputs"]["bar"] == ["flake2", "flake1"]
|
|
|
|
def test_simple_implicit(self, nix: Nix, flake3: Path):
|
|
(flake3 / "flake.nix").write_text("""{
|
|
inputs.bar.follows = "flake2";
|
|
|
|
outputs = { self, flake2, bar }: {};
|
|
}""")
|
|
nix.nix(["flake", "lock", flake3]).run().ok()
|
|
lock = json.loads((flake3 / "flake.lock").read_text())
|
|
assert lock["nodes"]["root"]["inputs"]["bar"] == ["flake2"]
|
|
|
|
class TestInputOverrides:
|
|
def test_simple_explicit(self, nix: Nix, flake3: Path, flake7: Path):
|
|
(flake3 / "flake.nix").write_text(f"""{{
|
|
inputs.flake2.inputs.flake1 = {{
|
|
type = "git";
|
|
url = "file://{flake7}";
|
|
}};
|
|
|
|
outputs = {{ self, flake2 }}: {{}};
|
|
}}""")
|
|
nix.nix(["flake", "lock", flake3]).run().ok()
|
|
lock = json.loads((flake3 / "flake.lock").read_text())
|
|
assert lock["nodes"]["flake1"]["locked"]["url"] == f"file://{flake7}"
|
|
|
|
def test_simple_follows(self, nix: Nix, flake3: Path, flake7: Path):
|
|
(flake3 / "flake.nix").write_text(f"""{{
|
|
inputs.flake2.inputs.flake1.follows = "foo";
|
|
inputs.foo.url = "git+file://{flake7}";
|
|
|
|
outputs = {{ self, flake2 }}: {{}};
|
|
}}""")
|
|
nix.nix(["flake", "lock", flake3]).run().ok()
|
|
lock = json.loads((flake3 / "flake.lock").read_text())
|
|
assert lock["nodes"]["flake2"]["inputs"]["flake1"] == ["foo"]
|
|
assert lock["nodes"]["foo"]["locked"]["url"] == f"file://{flake7}"
|
|
|
|
|
|
@pytest.mark.usefixtures("registry")
|
|
class TestMetadata:
|
|
def test_registry(self, nix: Nix):
|
|
metadata = nix.nix(["flake", "metadata", "flake1"]).run().ok().stdout_s
|
|
assert re.search(r"Locked URL:.*flake1.*", metadata)
|
|
|
|
@pytest.mark.parametrize("source", [[], ["."]])
|
|
def test_cwd(self, nix: Nix, flake1: Path, source: list[str]):
|
|
metadata = nix.nix(["flake", "metadata", *source], cwd=flake1).run().ok().stdout_s
|
|
assert re.search(r"Locked URL:.*flake1.*", metadata)
|
|
|
|
def test_absolute(self, nix: Nix, flake1: Path):
|
|
metadata = nix.nix(["flake", "metadata", flake1]).run().ok().stdout_s
|
|
assert re.search(r"Locked URL:.*flake1.*", metadata)
|
|
|
|
@pytest.mark.parametrize("source", ["flake1", None])
|
|
def test_json(self, nix: Nix, flake1: Path, source: str | None, git: Git):
|
|
flake1_original_commit = git(flake1, "rev-parse", "HEAD").stdout_s.strip()
|
|
metadata = nix.nix(["flake", "metadata", source or flake1, "--json"]).run().json()
|
|
assert metadata["description"] == "Bla bla"
|
|
assert Path(metadata["path"]).is_dir()
|
|
assert metadata["lastModified"] == 23
|
|
assert metadata["revision"] == flake1_original_commit
|
|
|
|
def test_json_registry_dirty(self, nix: Nix, flake1: Path, git: Git):
|
|
flake1_original_commit = git(flake1, "rev-parse", "HEAD").stdout_s.strip()
|
|
(flake1 / "foo").write_text("foo")
|
|
git(flake1, "add", "foo")
|
|
metadata = nix.nix(["flake", "metadata", "flake1", "--json"]).run().json()
|
|
assert metadata["dirtyRevision"] == f"{flake1_original_commit}-dirty"
|
|
|
|
_modify_flake1(flake1, git)
|
|
flake1_modified_commit = git(flake1, "rev-parse", "HEAD").stdout_s.strip()
|
|
metadata = nix.nix(["flake", "metadata", "flake1", "--json", "--refresh"]).run().json()
|
|
assert metadata["revision"] == flake1_modified_commit
|
|
assert "dirtyRevision" not in metadata
|
|
|
|
|
|
class TestAddPath:
|
|
@with_files({"badFlake": {"flake.nix": File("INVALID")}})
|
|
def test_does_not_eval(self, nix: Nix, files: Path):
|
|
nix.nix(["store", "add-path", str(files / "badFlake")]).run().ok()
|
|
|
|
def test_add_flake(self, nix: Nix, flake1: Path):
|
|
path = nix.nix(["store", "add-path", flake1]).run().ok().stdout_s.strip()
|
|
|
|
info = nix.nix(["path-info", path]).run().ok().stdout_s
|
|
assert "flake1" in info
|
|
|
|
# required to the path: test, otherwise outputs are not valid
|
|
nix.nix(["build", flake1]).run().ok()
|
|
info = nix.nix(["path-info", f"path:{path}"]).run().ok().stdout_s
|
|
assert "simple" in info
|
|
|
|
|
|
@pytest.mark.usefixtures("registry")
|
|
class TestLegacyCLI:
|
|
def test_instantiate_indirect(self, nix: Nix):
|
|
assert (
|
|
nix.nix_instantiate(["--eval", "flake:flake3", "-A", "x"]).run().ok().stdout_s
|
|
== "123\n"
|
|
)
|
|
|
|
def test_instantiate_url(self, nix: Nix, flake3: Path):
|
|
assert (
|
|
nix.nix_instantiate(["--eval", f"flake:git+file://{flake3}", "-A", "x"])
|
|
.run()
|
|
.ok()
|
|
.stdout_s
|
|
== "123\n"
|
|
)
|
|
|
|
def test_instantiate_nix_path_option(self, nix: Nix):
|
|
assert (
|
|
nix.nix_instantiate(["-I", "flake3=flake:flake3", "--eval", "<flake3>", "-A", "x"])
|
|
.run()
|
|
.ok()
|
|
.stdout_s
|
|
== "123\n"
|
|
)
|
|
|
|
def test_instantiate_nix_path_env(self, nix: Nix):
|
|
nix.env["NIX_PATH"] = "flake3=flake:flake3"
|
|
assert nix.nix_instantiate(["--eval", "<flake3>", "-A", "x"]).run().ok().stdout_s == "123\n"
|
|
|
|
|
|
class TestAlternateLockFiles:
|
|
@pytest.fixture(autouse=True)
|
|
def init(self, nix: Nix, flake1: Path, flake2: Path, registry: Path, git: Git): # noqa: ARG002
|
|
git(flake1, "commit", "--allow-empty", "-m", "to change branch head")
|
|
nix.nix(["flake", "lock", flake2]).run().ok()
|
|
|
|
def test_other_lockfile_is_identical(self, nix: Nix, flake2: Path):
|
|
nix.nix(["flake", "lock", flake2, "--output-lock-file", "flake2.lock"]).run().ok()
|
|
assert (nix.env.dirs.home / "flake2.lock").read_text() == (
|
|
flake2 / "flake.lock"
|
|
).read_text()
|
|
|
|
def test_input_overrides_change_lockfiles(self, nix: Nix, flake1: Path, flake2: Path, git: Git):
|
|
flake1_original_commit = git(flake1, "rev-parse", "HEAD").stdout_s.strip()
|
|
nix.nix(
|
|
[
|
|
"flake",
|
|
"lock",
|
|
flake2,
|
|
"--output-lock-file",
|
|
"flake2.lock",
|
|
"--override-input",
|
|
"flake1",
|
|
f"git+file://{flake1}?rev={flake1_original_commit}",
|
|
]
|
|
).run().ok()
|
|
assert (nix.env.dirs.home / "flake2.lock").read_text() != (
|
|
flake2 / "flake.lock"
|
|
).read_text()
|
|
assert (
|
|
flake1_original_commit
|
|
in nix.nix(["flake", "metadata", flake2, "--reference-lock-file", "flake2.lock"])
|
|
.run()
|
|
.ok()
|
|
.stdout_s
|
|
)
|
|
|
|
|
|
def test_reference_lock_file_requires_allow_dirty(nix: Nix, flake2: Path):
|
|
assert (
|
|
"error: reference lock file was provided, but the `allow-dirty` setting is set to false"
|
|
in nix.nix(
|
|
[
|
|
"flake",
|
|
"metadata",
|
|
flake2,
|
|
"--no-allow-dirty",
|
|
"--reference-lock-file",
|
|
f"{nix.env.dirs.home}/flake2-overridden.lock",
|
|
]
|
|
)
|
|
.run()
|
|
.expect(1)
|
|
.stderr_s
|
|
)
|