puck/lix
0
0
Fork 0
forked from lix-project/lix
Code Pull requests Activity
lix/tests/fetchGit.sh

204 lines
8.3 KiB
Bash
Raw Normal View History

fetchGit: Add a test
2017-11-03 12:33:50 +00:00
source common.sh
if [[ -z $(type -p git) ]]; then
echo "Git not installed; skipping Git tests"
Show when tests are skipped Also, don't depend on tput (ncurses). It's really not needed since ANSI escape sequences have been standardized for 35 years or so.
2017-11-07 11:06:58 +00:00
exit 99
fetchGit: Add a test
2017-11-03 12:33:50 +00:00
fi
clearStore
repo=$TEST_ROOT/git
exportGit: Don't clone local repositories This ensures that commands like 'nix flake info /my/nixpkgs' don't copy a gigabyte of crap to ~/.cache/nix. Fixes #60.
2019-04-19 12:06:27 +00:00
export _NIX_FORCE_HTTP=1
Git: Use unified caching system
2020-03-17 21:32:26 +00:00
rm -rf $repo ${repo}-tmp $TEST_HOME/.cache/nix $TEST_ROOT/worktree $TEST_ROOT/shallow
fetchGit: Add a test
2017-11-03 12:33:50 +00:00
git init $repo
git -C $repo config user.email "foobar@example.com"
git -C $repo config user.name "Foobar"
echo utrecht > $repo/hello
fetchGit/fetchMercurial: Fix directory inclusion check E.g. the existence of .gitignore would cause .git to be included.
2017-11-21 18:12:47 +00:00
touch $repo/.gitignore
git -C $repo add hello .gitignore
fetchGit: Add a test
2017-11-03 12:33:50 +00:00
git -C $repo commit -m 'Bla1'
rev1=$(git -C $repo rev-parse HEAD)
echo world > $repo/hello
git -C $repo commit -m 'Bla2' -a
builtins.fetchGit: Fix build when fetching a git worktree Worktrees[1] are a feature of git which allow you to check out a ref in a different directory. While playing around with flakes I realized that git repositories in a worktree checkout break when trying to build a flake: ``` $ git worktree add ../nixpkgs-flakes nixpkgs-flakes $ cd ../nixpkgs-flakes $ nix build .#hello error: opening directory '/home/ma27/Projects/nixpkgs-flakes/.git/refs/heads': Not a directory ``` This issue has been fixed by determining with `git rev-parse --git-common-dir` where the actual `.git` directory is. Please note that this issue only exists on the `flakes` branch, fetching worktree checkouts with Nix master seems to work fine. [1] https://git-scm.com/docs/git-worktree
2019-11-15 12:04:42 +00:00
git -C $repo worktree add $TEST_ROOT/worktree
echo hello >> $TEST_ROOT/worktree/hello
fetchGit: Add a test
2017-11-03 12:33:50 +00:00
rev2=$(git -C $repo rev-parse HEAD)
builtins.fetchGit: Fix build when fetching a git worktree Worktrees[1] are a feature of git which allow you to check out a ref in a different directory. While playing around with flakes I realized that git repositories in a worktree checkout break when trying to build a flake: ``` $ git worktree add ../nixpkgs-flakes nixpkgs-flakes $ cd ../nixpkgs-flakes $ nix build .#hello error: opening directory '/home/ma27/Projects/nixpkgs-flakes/.git/refs/heads': Not a directory ``` This issue has been fixed by determining with `git rev-parse --git-common-dir` where the actual `.git` directory is. Please note that this issue only exists on the `flakes` branch, fetching worktree checkouts with Nix master seems to work fine. [1] https://git-scm.com/docs/git-worktree
2019-11-15 12:04:42 +00:00
# Fetch a worktree
unset _NIX_FORCE_HTTP
path0=$(nix eval --impure --raw --expr "(builtins.fetchGit file://$TEST_ROOT/worktree).outPath")
Merge legacy `fetchGit`-builtin with the generic `fetchTree`-function The original idea was to implement a git-fetcher in Nix's core that supports content hashes[1]. In #3549[2] it has been suggested to actually use `fetchTree` for this since it's a fairly generic wrapper over the new fetcher-API[3] and already supports content-hashes. This patch implements a new git-fetcher based on `fetchTree` by incorporating the following changes: * Removed the original `fetchGit`-implementation and replaced it with an alias on the `fetchTree` implementation. * Ensured that the `git`-fetcher from `libfetchers` always computes a content-hash and returns an "empty" revision on dirty trees (the latter one is needed to retain backwards-compatibility). * The hash-mismatch error in the fetcher-API exits with code 102 as it usually happens whenever a hash-mismatch is detected by Nix. * Removed the `flakes`-feature-flag: I didn't see a reason why this API is so tightly coupled to the flakes-API and at least `fetchGit` should remain usable without any feature-flags. * It's only possible to specify a `narHash` for a `git`-tree if either a `ref` or a `rev` is given[4]. * It's now possible to specify an URL without a protocol. If it's missing, `file://` is automatically added as it was the case in the original `fetchGit`-implementation. [1] https://github.com/NixOS/nix/pull/3216 [2] https://github.com/NixOS/nix/pull/3549#issuecomment-625194383 [3] https://github.com/NixOS/nix/pull/3459 [4] https://github.com/NixOS/nix/pull/3216#issuecomment-553956703
2020-04-29 20:39:58 +00:00
path0_=$(nix eval --impure --raw --expr "(builtins.fetchTree { type = \"git\"; url = file://$TEST_ROOT/worktree; }).outPath")
[[ $path0 = $path0_ ]]
builtins.fetchGit: Fix build when fetching a git worktree Worktrees[1] are a feature of git which allow you to check out a ref in a different directory. While playing around with flakes I realized that git repositories in a worktree checkout break when trying to build a flake: ``` $ git worktree add ../nixpkgs-flakes nixpkgs-flakes $ cd ../nixpkgs-flakes $ nix build .#hello error: opening directory '/home/ma27/Projects/nixpkgs-flakes/.git/refs/heads': Not a directory ``` This issue has been fixed by determining with `git rev-parse --git-common-dir` where the actual `.git` directory is. Please note that this issue only exists on the `flakes` branch, fetching worktree checkouts with Nix master seems to work fine. [1] https://git-scm.com/docs/git-worktree
2019-11-15 12:04:42 +00:00
export _NIX_FORCE_HTTP=1
[[ $(tail -n 1 $path0/hello) = "hello" ]]
fetchGit: Add a test
2017-11-03 12:33:50 +00:00
# Fetch the default branch.
nix: Add --expr flag This replaces the '(...)' installable syntax, which is not very discoverable. The downside is that you can't have multiple expressions or mix expressions and other installables.
2019-11-26 23:05:30 +00:00
path=$(nix eval --impure --raw --expr "(builtins.fetchGit file://$repo).outPath")
fetchGit: Add a test
2017-11-03 12:33:50 +00:00
[[ $(cat $path/hello) = world ]]
tests/fetchGit: test behavior of `allRefs = true;`
2020-12-22 11:18:10 +00:00
# Fetch a rev from another branch
git -C $repo checkout -b devtest
echo "different file" >> $TEST_ROOT/git/differentbranch
git -C $repo add differentbranch
git -C $repo commit -m 'Test2'
git -C $repo checkout master
devrev=$(git -C $repo rev-parse devtest)
out=$(nix eval --impure --raw --expr "builtins.fetchGit { url = file://$repo; rev = \"$devrev\"; }" 2>&1) || status=$?
[[ $status == 1 ]]
[[ $out =~ 'Cannot find Git revision' ]]
[[ $(nix eval --raw --expr "builtins.readFile (builtins.fetchGit { url = file://$repo; rev = \"$devrev\"; allRefs = true; } + \"/differentbranch\")") = 'different file' ]]
Add pure evaluation mode In this mode, the following restrictions apply: * The builtins currentTime, currentSystem and storePath throw an error. * $NIX_PATH and -I are ignored. * fetchGit and fetchMercurial require a revision hash. * fetchurl and fetchTarball require a sha256 attribute. * No file system access is allowed outside of the paths returned by fetch{Git,Mercurial,url,Tarball}. Thus 'nix build -f ./foo.nix' is not allowed. Thus, the evaluation result is completely reproducible from the command line arguments. E.g. nix build --pure-eval '( let nix = fetchGit { url = https://github.com/NixOS/nixpkgs.git; rev = "9c927de4b179a6dd210dd88d34bda8af4b575680"; }; nixpkgs = fetchGit { url = https://github.com/NixOS/nixpkgs.git; ref = "release-17.09"; rev = "66b4de79e3841530e6d9c6baf98702aa1f7124e4"; }; in (import (nix + "/release.nix") { inherit nix nixpkgs; }).build.x86_64-linux )' The goal is to enable completely reproducible and traceable evaluation. For example, a NixOS configuration could be fully described by a single Git commit hash. 'nixos-rebuild' would do something like nix build --pure-eval '( (import (fetchGit { url = file:///my-nixos-config; rev = "..."; })).system ') where the Git repository /my-nixos-config would use further fetchGit calls or Git externals to fetch Nixpkgs and whatever other dependencies it has. Either way, the commit hash would uniquely identify the NixOS configuration and allow it to reproduced.
2018-01-16 17:50:38 +00:00
# In pure eval mode, fetchGit without a revision should fail.
nix: Add --expr flag This replaces the '(...)' installable syntax, which is not very discoverable. The downside is that you can't have multiple expressions or mix expressions and other installables.
2019-11-26 23:05:30 +00:00
[[ $(nix eval --impure --raw --expr "builtins.readFile (fetchGit file://$repo + \"/hello\")") = world ]]
(! nix eval --raw --expr "builtins.readFile (fetchGit file://$repo + \"/hello\")")
Add pure evaluation mode In this mode, the following restrictions apply: * The builtins currentTime, currentSystem and storePath throw an error. * $NIX_PATH and -I are ignored. * fetchGit and fetchMercurial require a revision hash. * fetchurl and fetchTarball require a sha256 attribute. * No file system access is allowed outside of the paths returned by fetch{Git,Mercurial,url,Tarball}. Thus 'nix build -f ./foo.nix' is not allowed. Thus, the evaluation result is completely reproducible from the command line arguments. E.g. nix build --pure-eval '( let nix = fetchGit { url = https://github.com/NixOS/nixpkgs.git; rev = "9c927de4b179a6dd210dd88d34bda8af4b575680"; }; nixpkgs = fetchGit { url = https://github.com/NixOS/nixpkgs.git; ref = "release-17.09"; rev = "66b4de79e3841530e6d9c6baf98702aa1f7124e4"; }; in (import (nix + "/release.nix") { inherit nix nixpkgs; }).build.x86_64-linux )' The goal is to enable completely reproducible and traceable evaluation. For example, a NixOS configuration could be fully described by a single Git commit hash. 'nixos-rebuild' would do something like nix build --pure-eval '( (import (fetchGit { url = file:///my-nixos-config; rev = "..."; })).system ') where the Git repository /my-nixos-config would use further fetchGit calls or Git externals to fetch Nixpkgs and whatever other dependencies it has. Either way, the commit hash would uniquely identify the NixOS configuration and allow it to reproduced.
2018-01-16 17:50:38 +00:00
fetchGit: Add a test
2017-11-03 12:33:50 +00:00
# Fetch using an explicit revision hash.
nix: Add --expr flag This replaces the '(...)' installable syntax, which is not very discoverable. The downside is that you can't have multiple expressions or mix expressions and other installables.
2019-11-26 23:05:30 +00:00
path2=$(nix eval --raw --expr "(builtins.fetchGit { url = file://$repo; rev = \"$rev2\"; }).outPath")
fetchGit: Add a test
2017-11-03 12:33:50 +00:00
[[ $path = $path2 ]]
Add pure evaluation mode In this mode, the following restrictions apply: * The builtins currentTime, currentSystem and storePath throw an error. * $NIX_PATH and -I are ignored. * fetchGit and fetchMercurial require a revision hash. * fetchurl and fetchTarball require a sha256 attribute. * No file system access is allowed outside of the paths returned by fetch{Git,Mercurial,url,Tarball}. Thus 'nix build -f ./foo.nix' is not allowed. Thus, the evaluation result is completely reproducible from the command line arguments. E.g. nix build --pure-eval '( let nix = fetchGit { url = https://github.com/NixOS/nixpkgs.git; rev = "9c927de4b179a6dd210dd88d34bda8af4b575680"; }; nixpkgs = fetchGit { url = https://github.com/NixOS/nixpkgs.git; ref = "release-17.09"; rev = "66b4de79e3841530e6d9c6baf98702aa1f7124e4"; }; in (import (nix + "/release.nix") { inherit nix nixpkgs; }).build.x86_64-linux )' The goal is to enable completely reproducible and traceable evaluation. For example, a NixOS configuration could be fully described by a single Git commit hash. 'nixos-rebuild' would do something like nix build --pure-eval '( (import (fetchGit { url = file:///my-nixos-config; rev = "..."; })).system ') where the Git repository /my-nixos-config would use further fetchGit calls or Git externals to fetch Nixpkgs and whatever other dependencies it has. Either way, the commit hash would uniquely identify the NixOS configuration and allow it to reproduced.
2018-01-16 17:50:38 +00:00
# In pure eval mode, fetchGit with a revision should succeed.
nix: Add --expr flag This replaces the '(...)' installable syntax, which is not very discoverable. The downside is that you can't have multiple expressions or mix expressions and other installables.
2019-11-26 23:05:30 +00:00
[[ $(nix eval --raw --expr "builtins.readFile (fetchGit { url = file://$repo; rev = \"$rev2\"; } + \"/hello\")") = world ]]
Add pure evaluation mode In this mode, the following restrictions apply: * The builtins currentTime, currentSystem and storePath throw an error. * $NIX_PATH and -I are ignored. * fetchGit and fetchMercurial require a revision hash. * fetchurl and fetchTarball require a sha256 attribute. * No file system access is allowed outside of the paths returned by fetch{Git,Mercurial,url,Tarball}. Thus 'nix build -f ./foo.nix' is not allowed. Thus, the evaluation result is completely reproducible from the command line arguments. E.g. nix build --pure-eval '( let nix = fetchGit { url = https://github.com/NixOS/nixpkgs.git; rev = "9c927de4b179a6dd210dd88d34bda8af4b575680"; }; nixpkgs = fetchGit { url = https://github.com/NixOS/nixpkgs.git; ref = "release-17.09"; rev = "66b4de79e3841530e6d9c6baf98702aa1f7124e4"; }; in (import (nix + "/release.nix") { inherit nix nixpkgs; }).build.x86_64-linux )' The goal is to enable completely reproducible and traceable evaluation. For example, a NixOS configuration could be fully described by a single Git commit hash. 'nixos-rebuild' would do something like nix build --pure-eval '( (import (fetchGit { url = file:///my-nixos-config; rev = "..."; })).system ') where the Git repository /my-nixos-config would use further fetchGit calls or Git externals to fetch Nixpkgs and whatever other dependencies it has. Either way, the commit hash would uniquely identify the NixOS configuration and allow it to reproduced.
2018-01-16 17:50:38 +00:00
fetchGit: Add a test
2017-11-03 12:33:50 +00:00
# Fetch again. This should be cached.
mv $repo ${repo}-tmp
nix: Add --expr flag This replaces the '(...)' installable syntax, which is not very discoverable. The downside is that you can't have multiple expressions or mix expressions and other installables.
2019-11-26 23:05:30 +00:00
path2=$(nix eval --impure --raw --expr "(builtins.fetchGit file://$repo).outPath")
fetchGit: Add a test
2017-11-03 12:33:50 +00:00
[[ $path = $path2 ]]
nix: Add --expr flag This replaces the '(...)' installable syntax, which is not very discoverable. The downside is that you can't have multiple expressions or mix expressions and other installables.
2019-11-26 23:05:30 +00:00
[[ $(nix eval --impure --expr "(builtins.fetchGit file://$repo).revCount") = 2 ]]
[[ $(nix eval --impure --raw --expr "(builtins.fetchGit file://$repo).rev") = $rev2 ]]
builtins.fetchGit: Fix shortRev attribute for dirty trees
2020-11-26 20:45:28 +00:00
[[ $(nix eval --impure --raw --expr "(builtins.fetchGit file://$repo).shortRev") = ${rev2:0:7} ]]
fetchGit: Add a test
2017-11-03 12:33:50 +00:00
# Fetching with a explicit hash should succeed.
Git: Use unified caching system
2020-03-17 21:32:26 +00:00
path2=$(nix eval --refresh --raw --expr "(builtins.fetchGit { url = file://$repo; rev = \"$rev2\"; }).outPath")
fetchGit: Add a test
2017-11-03 12:33:50 +00:00
[[ $path = $path2 ]]
Git: Use unified caching system
2020-03-17 21:32:26 +00:00
path2=$(nix eval --refresh --raw --expr "(builtins.fetchGit { url = file://$repo; rev = \"$rev1\"; }).outPath")
fetchGit: Add a test
2017-11-03 12:33:50 +00:00
[[ $(cat $path2/hello) = utrecht ]]
mv ${repo}-tmp $repo
# Using a clean working tree should produce the same result.
nix: Add --expr flag This replaces the '(...)' installable syntax, which is not very discoverable. The downside is that you can't have multiple expressions or mix expressions and other installables.
2019-11-26 23:05:30 +00:00
path2=$(nix eval --impure --raw --expr "(builtins.fetchGit $repo).outPath")
fetchGit: Add a test
2017-11-03 12:33:50 +00:00
[[ $path = $path2 ]]
# Using an unclean tree should yield the tracked but uncommitted changes.
fetchGit/fetchMercurial: Filter out directories with untracked files
2017-11-03 12:48:02 +00:00
mkdir $repo/dir1 $repo/dir2
echo foo > $repo/dir1/foo
fetchGit: Add a test
2017-11-03 12:33:50 +00:00
echo bar > $repo/bar
fetchGit/fetchMercurial: Filter out directories with untracked files
2017-11-03 12:48:02 +00:00
echo bar > $repo/dir2/bar
git -C $repo add dir1/foo
fetchGit: Add a test
2017-11-03 12:33:50 +00:00
git -C $repo rm hello
Pluggable fetchers Flakes are now fetched using an extensible mechanism. Also lots of other flake cleanups.
2020-01-21 15:27:53 +00:00
unset _NIX_FORCE_HTTP
nix: Add --expr flag This replaces the '(...)' installable syntax, which is not very discoverable. The downside is that you can't have multiple expressions or mix expressions and other installables.
2019-11-26 23:05:30 +00:00
path2=$(nix eval --impure --raw --expr "(builtins.fetchGit $repo).outPath")
fetchGit: Add a test
2017-11-03 12:33:50 +00:00
[ ! -e $path2/hello ]
[ ! -e $path2/bar ]
fetchGit/fetchMercurial: Filter out directories with untracked files
2017-11-03 12:48:02 +00:00
[ ! -e $path2/dir2/bar ]
fetchGit/fetchMercurial: Fix directory inclusion check E.g. the existence of .gitignore would cause .git to be included.
2017-11-21 18:12:47 +00:00
[ ! -e $path2/.git ]
fetchGit/fetchMercurial: Filter out directories with untracked files
2017-11-03 12:48:02 +00:00
[[ $(cat $path2/dir1/foo) = foo ]]
fetchGit: Add a test
2017-11-03 12:33:50 +00:00
Restore backwards-compat for current `builtins.fetchGit` If a repo is dirty, it used to return a `rev` object with an "empty" sha1 (0000000000000000000000000000000000000000). Please note that this only applies for `builtins.fetchGit` and *not* for `builtins.fetchTree{ type = "git"; }`.
2020-07-28 20:46:39 +00:00
[[ $(nix eval --impure --raw --expr "(builtins.fetchGit $repo).rev") = 0000000000000000000000000000000000000000 ]]
fetchGit: Add a test
2017-11-03 12:33:50 +00:00
# ... unless we're using an explicit ref or rev.
nix: Add --expr flag This replaces the '(...)' installable syntax, which is not very discoverable. The downside is that you can't have multiple expressions or mix expressions and other installables.
2019-11-26 23:05:30 +00:00
path3=$(nix eval --impure --raw --expr "(builtins.fetchGit { url = $repo; ref = \"master\"; }).outPath")
fetchGit: Add a test
2017-11-03 12:33:50 +00:00
[[ $path = $path3 ]]
nix: Add --expr flag This replaces the '(...)' installable syntax, which is not very discoverable. The downside is that you can't have multiple expressions or mix expressions and other installables.
2019-11-26 23:05:30 +00:00
path3=$(nix eval --raw --expr "(builtins.fetchGit { url = $repo; rev = \"$rev2\"; }).outPath")
fetchGit: Add a test
2017-11-03 12:33:50 +00:00
[[ $path = $path3 ]]
# Committing should not affect the store path.
git -C $repo commit -m 'Bla3' -a
Git: Use unified caching system
2020-03-17 21:32:26 +00:00
path4=$(nix eval --impure --refresh --raw --expr "(builtins.fetchGit file://$repo).outPath")
fetchGit: Add a test
2017-11-03 12:33:50 +00:00
[[ $path2 = $path4 ]]
fetchGit: Ignore tarballTtl if rev is set and not in the repo. Fixes #1697.
2017-11-24 02:50:01 +00:00
Merge legacy `fetchGit`-builtin with the generic `fetchTree`-function The original idea was to implement a git-fetcher in Nix's core that supports content hashes[1]. In #3549[2] it has been suggested to actually use `fetchTree` for this since it's a fairly generic wrapper over the new fetcher-API[3] and already supports content-hashes. This patch implements a new git-fetcher based on `fetchTree` by incorporating the following changes: * Removed the original `fetchGit`-implementation and replaced it with an alias on the `fetchTree` implementation. * Ensured that the `git`-fetcher from `libfetchers` always computes a content-hash and returns an "empty" revision on dirty trees (the latter one is needed to retain backwards-compatibility). * The hash-mismatch error in the fetcher-API exits with code 102 as it usually happens whenever a hash-mismatch is detected by Nix. * Removed the `flakes`-feature-flag: I didn't see a reason why this API is so tightly coupled to the flakes-API and at least `fetchGit` should remain usable without any feature-flags. * It's only possible to specify a `narHash` for a `git`-tree if either a `ref` or a `rev` is given[4]. * It's now possible to specify an URL without a protocol. If it's missing, `file://` is automatically added as it was the case in the original `fetchGit`-implementation. [1] https://github.com/NixOS/nix/pull/3216 [2] https://github.com/NixOS/nix/pull/3549#issuecomment-625194383 [3] https://github.com/NixOS/nix/pull/3459 [4] https://github.com/NixOS/nix/pull/3216#issuecomment-553956703
2020-04-29 20:39:58 +00:00
nix eval --impure --raw --expr "(builtins.fetchGit { url = $repo; rev = \"$rev2\"; narHash = \"sha256-B5yIPHhEm0eysJKEsO7nqxprh9vcblFxpJG11gXJus1=\"; }).outPath" || status=$?
[[ "$status" = "102" ]]
path5=$(nix eval --impure --raw --expr "(builtins.fetchGit { url = $repo; rev = \"$rev2\"; narHash = \"sha256-Hr8g6AqANb3xqX28eu1XnjK/3ab8Gv6TJSnkb1LezG9=\"; }).outPath")
[[ $path = $path5 ]]
fetchGit: Ignore tarballTtl if rev is set and not in the repo. Fixes #1697.
2017-11-24 02:50:01 +00:00
# tarball-ttl should be ignored if we specify a rev
echo delft > $repo/hello
git -C $repo add hello
git -C $repo commit -m 'Bla4'
rev3=$(git -C $repo rev-parse HEAD)
nix: Add --expr flag This replaces the '(...)' installable syntax, which is not very discoverable. The downside is that you can't have multiple expressions or mix expressions and other installables.
2019-11-26 23:05:30 +00:00
nix eval --tarball-ttl 3600 --expr "builtins.fetchGit { url = $repo; rev = \"$rev3\"; }" >/dev/null
fetchGit: Fix handling of local repo when not using 'master' branch Add tests checking this behavior.
2017-12-22 20:18:29 +00:00
# Update 'path' to reflect latest master
nix: Add --expr flag This replaces the '(...)' installable syntax, which is not very discoverable. The downside is that you can't have multiple expressions or mix expressions and other installables.
2019-11-26 23:05:30 +00:00
path=$(nix eval --impure --raw --expr "(builtins.fetchGit file://$repo).outPath")
fetchGit: Fix handling of local repo when not using 'master' branch Add tests checking this behavior.
2017-12-22 20:18:29 +00:00
# Check behavior when non-master branch is used
git -C $repo checkout $rev2 -b dev
echo dev > $repo/hello
Pluggable fetchers Flakes are now fetched using an extensible mechanism. Also lots of other flake cleanups.
2020-01-21 15:27:53 +00:00
# File URI uses dirty tree unless specified otherwise
nix: Add --expr flag This replaces the '(...)' installable syntax, which is not very discoverable. The downside is that you can't have multiple expressions or mix expressions and other installables.
2019-11-26 23:05:30 +00:00
path2=$(nix eval --impure --raw --expr "(builtins.fetchGit file://$repo).outPath")
Pluggable fetchers Flakes are now fetched using an extensible mechanism. Also lots of other flake cleanups.
2020-01-21 15:27:53 +00:00
[ $(cat $path2/hello) = dev ]
fetchGit: Fix handling of local repo when not using 'master' branch Add tests checking this behavior.
2017-12-22 20:18:29 +00:00
# Using local path with branch other than 'master' should work when clean or dirty
nix: Add --expr flag This replaces the '(...)' installable syntax, which is not very discoverable. The downside is that you can't have multiple expressions or mix expressions and other installables.
2019-11-26 23:05:30 +00:00
path3=$(nix eval --impure --raw --expr "(builtins.fetchGit $repo).outPath")
fetchGit: Fix handling of local repo when not using 'master' branch Add tests checking this behavior.
2017-12-22 20:18:29 +00:00
# (check dirty-tree handling was used)
Restore backwards-compat for current `builtins.fetchGit` If a repo is dirty, it used to return a `rev` object with an "empty" sha1 (0000000000000000000000000000000000000000). Please note that this only applies for `builtins.fetchGit` and *not* for `builtins.fetchTree{ type = "git"; }`.
2020-07-28 20:46:39 +00:00
[[ $(nix eval --impure --raw --expr "(builtins.fetchGit $repo).rev") = 0000000000000000000000000000000000000000 ]]
builtins.fetchGit: Fix shortRev attribute for dirty trees
2020-11-26 20:45:28 +00:00
[[ $(nix eval --impure --raw --expr "(builtins.fetchGit $repo).shortRev") = 0000000 ]]
fetchGit: Fix handling of local repo when not using 'master' branch Add tests checking this behavior.
2017-12-22 20:18:29 +00:00
# Committing shouldn't change store path, or switch to using 'master'
git -C $repo commit -m 'Bla5' -a
nix: Add --expr flag This replaces the '(...)' installable syntax, which is not very discoverable. The downside is that you can't have multiple expressions or mix expressions and other installables.
2019-11-26 23:05:30 +00:00
path4=$(nix eval --impure --raw --expr "(builtins.fetchGit $repo).outPath")
fetchGit: Fix handling of local repo when not using 'master' branch Add tests checking this behavior.
2017-12-22 20:18:29 +00:00
[[ $(cat $path4/hello) = dev ]]
[[ $path3 = $path4 ]]
# Confirm same as 'dev' branch
nix: Add --expr flag This replaces the '(...)' installable syntax, which is not very discoverable. The downside is that you can't have multiple expressions or mix expressions and other installables.
2019-11-26 23:05:30 +00:00
path5=$(nix eval --impure --raw --expr "(builtins.fetchGit { url = $repo; ref = \"dev\"; }).outPath")
fetchGit: Fix handling of local repo when not using 'master' branch Add tests checking this behavior.
2017-12-22 20:18:29 +00:00
[[ $path3 = $path5 ]]
fetchGit.sh: Test we don't "corrupt" cache if invoke w/o git avail
2018-01-09 14:58:19 +00:00
# Nuke the cache
Git: Use unified caching system
2020-03-17 21:32:26 +00:00
rm -rf $TEST_HOME/.cache/nix
fetchGit.sh: Test we don't "corrupt" cache if invoke w/o git avail
2018-01-09 14:58:19 +00:00
Git: Use unified caching system
2020-03-17 21:32:26 +00:00
# Try again, but without 'git' on PATH. This should fail.
fetchGit.sh: Test we don't "corrupt" cache if invoke w/o git avail
2018-01-09 14:58:19 +00:00
NIX=$(command -v nix)
nix: Add --expr flag This replaces the '(...)' installable syntax, which is not very discoverable. The downside is that you can't have multiple expressions or mix expressions and other installables.
2019-11-26 23:05:30 +00:00
(! PATH= $NIX eval --impure --raw --expr "(builtins.fetchGit { url = $repo; ref = \"dev\"; }).outPath" )
fetchGit.sh: Test we don't "corrupt" cache if invoke w/o git avail
2018-01-09 14:58:19 +00:00
# Try again, with 'git' available. This should work.
nix: Add --expr flag This replaces the '(...)' installable syntax, which is not very discoverable. The downside is that you can't have multiple expressions or mix expressions and other installables.
2019-11-26 23:05:30 +00:00
path5=$(nix eval --impure --raw --expr "(builtins.fetchGit { url = $repo; ref = \"dev\"; }).outPath")
fetchGit.sh: Test we don't "corrupt" cache if invoke w/o git avail
2018-01-09 14:58:19 +00:00
[[ $path3 = $path5 ]]
Add a test for shallow Git clones Also, don't return a revCount anymore for shallow or dirty Git trees, since it's incorrect. Closes #2988.
2020-03-16 12:20:32 +00:00
git fetcher: improve check for valid repository The .git/refs/heads directory might be empty for a valid usable git repository. This often happens in CI environments, which might only fetch commits, not branches. Therefore instead we let git itself check if HEAD points to something that looks like a commit. fixes #5302
2021-12-13 20:31:15 +00:00
# Fetching from a repo with only a specific revision and no branches should
# not fall back to copying files and record correct revision information. See: #5302
mkdir $TEST_ROOT/minimal
git -C $TEST_ROOT/minimal init
git -C $TEST_ROOT/minimal fetch $repo $rev2
git -C $TEST_ROOT/minimal checkout $rev2
[[ $(nix eval --impure --raw --expr "(builtins.fetchGit { url = $TEST_ROOT/minimal; }).rev") = $rev2 ]]
Require shallow clones to be requested explicitly If you do a fetchTree on a Git repository, whether the result contains a revCount attribute should not depend on whether that repository happens to be a shallow clone or not. That would complicate caching a lot and would be semantically messy. So applying fetchTree/fetchGit to a shallow repository is now an error unless you pass the attribute 'shallow = true'. If 'shallow = true', we don't return revCount, even if the repository is not actually shallow. Note that Nix itself is not doing shallow clones at the moment. But it could do so as an optimisation if the user specifies 'shallow = true'. Issue #2988.
2020-03-17 20:34:38 +00:00
# Fetching a shallow repo shouldn't work by default, because we can't
# return a revCount.
Add a test for shallow Git clones Also, don't return a revCount anymore for shallow or dirty Git trees, since it's incorrect. Closes #2988.
2020-03-16 12:20:32 +00:00
git clone --depth 1 file://$repo $TEST_ROOT/shallow
Require shallow clones to be requested explicitly If you do a fetchTree on a Git repository, whether the result contains a revCount attribute should not depend on whether that repository happens to be a shallow clone or not. That would complicate caching a lot and would be semantically messy. So applying fetchTree/fetchGit to a shallow repository is now an error unless you pass the attribute 'shallow = true'. If 'shallow = true', we don't return revCount, even if the repository is not actually shallow. Note that Nix itself is not doing shallow clones at the moment. But it could do so as an optimisation if the user specifies 'shallow = true'. Issue #2988.
2020-03-17 20:34:38 +00:00
(! nix eval --impure --raw --expr "(builtins.fetchGit { url = $TEST_ROOT/shallow; ref = \"dev\"; }).outPath")
# But you can request a shallow clone, which won't return a revCount.
path6=$(nix eval --impure --raw --expr "(builtins.fetchTree { type = \"git\"; url = \"file://$TEST_ROOT/shallow\"; ref = \"dev\"; shallow = true; }).outPath")
Add a test for shallow Git clones Also, don't return a revCount anymore for shallow or dirty Git trees, since it's incorrect. Closes #2988.
2020-03-16 12:20:32 +00:00
[[ $path3 = $path6 ]]
Require shallow clones to be requested explicitly If you do a fetchTree on a Git repository, whether the result contains a revCount attribute should not depend on whether that repository happens to be a shallow clone or not. That would complicate caching a lot and would be semantically messy. So applying fetchTree/fetchGit to a shallow repository is now an error unless you pass the attribute 'shallow = true'. If 'shallow = true', we don't return revCount, even if the repository is not actually shallow. Note that Nix itself is not doing shallow clones at the moment. But it could do so as an optimisation if the user specifies 'shallow = true'. Issue #2988.
2020-03-17 20:34:38 +00:00
[[ $(nix eval --impure --expr "(builtins.fetchTree { type = \"git\"; url = \"file://$TEST_ROOT/shallow\"; ref = \"dev\"; shallow = true; }).revCount or 123") == 123 ]]
tests: check that builtins.fetchGit { ..., ref = "HEAD"; } works
2021-03-30 09:39:37 +00:00
# Explicit ref = "HEAD" should work, and produce the same outPath as without ref
path7=$(nix eval --impure --raw --expr "(builtins.fetchGit { url = \"file://$repo\"; ref = \"HEAD\"; }).outPath")
path8=$(nix eval --impure --raw --expr "(builtins.fetchGit { url = \"file://$repo\"; }).outPath")
[[ $path7 = $path8 ]]
# ref = "HEAD" should fetch the HEAD revision
rev4=$(git -C $repo rev-parse HEAD)
rev4_nix=$(nix eval --impure --raw --expr "(builtins.fetchGit { url = \"file://$repo\"; ref = \"HEAD\"; }).rev")
[[ $rev4 = $rev4_nix ]]
Allow `fetchGit` to take a `name` argument Fix #3388
2021-07-05 11:09:46 +00:00
# The name argument should be handled
path9=$(nix eval --impure --raw --expr "(builtins.fetchGit { url = \"file://$repo\"; ref = \"HEAD\"; name = \"foo\"; }).outPath")
[[ $path9 =~ -foo$ ]]
Copy permalink