2014-06-15 19:02:47 +02:00
|
|
|
#!/bin/sh
|
|
|
|
|
|
|
|
test_description='pull can handle submodules'
|
|
|
|
|
|
|
|
. ./test-lib.sh
|
|
|
|
. "$TEST_DIRECTORY"/lib-submodule-update.sh
|
|
|
|
|
|
|
|
reset_branch_to_HEAD () {
|
|
|
|
git branch -D "$1" &&
|
|
|
|
git checkout -b "$1" HEAD &&
|
|
|
|
git branch --set-upstream-to="origin/$1" "$1"
|
|
|
|
}
|
|
|
|
|
|
|
|
git_pull () {
|
|
|
|
reset_branch_to_HEAD "$1" &&
|
lib-submodule-update: pass 'test_must_fail' as an argument
When we run a test helper function in test_submodule_switch_common(), we
sometimes specify a whole helper function as the $command. When we do
this, in some test cases, we just mark the whole function with
`test_must_fail`. However, it's possible that the helper function might
fail earlier or later than expected due to an introduced bug. If this
happens, then the test case will still report as passing but it should
really be marked as failing since it didn't actually display the
intended behaviour.
Instead of invoking `test_must_fail $command`, pass the string
"test_must_fail" as the second argument in case where the git command is
expected to fail.
When $command is a helper function, the parent function calling
test_submodule_switch_common() is test_submodule_switch_func(). For all
test_submodule_switch_func() invocations, increase the granularity of
the argument test helper function by prefixing the git invocation which is
meant to fail with the second argument like this:
$2 git checkout "$1"
In the other cases, test_submodule_switch() and
test_submodule_forced_switch(), instead of passing in the git command
directly, wrap it using the git_test_func() and pass the git arguments
using the global variable $gitcmd. Unfortunately, since closures aren't
a thing in shell scripts, the global variable is necessary. Another
unfortunate result is that the "git_test_func" will used as the test
case name when $command is printed but it's worth it for the cleaner
code.
Finally, as an added bonus, `test_must_fail` will now only run on git
commands.
Signed-off-by: Denton Liu <liu.denton@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-06-24 10:50:18 +02:00
|
|
|
may_only_be_test_must_fail "$2" &&
|
|
|
|
$2 git pull
|
2014-06-15 19:02:47 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
# pulls without conflicts
|
2020-06-11 19:41:49 +02:00
|
|
|
test_submodule_switch_func "git_pull"
|
2014-06-15 19:02:47 +02:00
|
|
|
|
|
|
|
git_pull_ff () {
|
|
|
|
reset_branch_to_HEAD "$1" &&
|
lib-submodule-update: pass 'test_must_fail' as an argument
When we run a test helper function in test_submodule_switch_common(), we
sometimes specify a whole helper function as the $command. When we do
this, in some test cases, we just mark the whole function with
`test_must_fail`. However, it's possible that the helper function might
fail earlier or later than expected due to an introduced bug. If this
happens, then the test case will still report as passing but it should
really be marked as failing since it didn't actually display the
intended behaviour.
Instead of invoking `test_must_fail $command`, pass the string
"test_must_fail" as the second argument in case where the git command is
expected to fail.
When $command is a helper function, the parent function calling
test_submodule_switch_common() is test_submodule_switch_func(). For all
test_submodule_switch_func() invocations, increase the granularity of
the argument test helper function by prefixing the git invocation which is
meant to fail with the second argument like this:
$2 git checkout "$1"
In the other cases, test_submodule_switch() and
test_submodule_forced_switch(), instead of passing in the git command
directly, wrap it using the git_test_func() and pass the git arguments
using the global variable $gitcmd. Unfortunately, since closures aren't
a thing in shell scripts, the global variable is necessary. Another
unfortunate result is that the "git_test_func" will used as the test
case name when $command is printed but it's worth it for the cleaner
code.
Finally, as an added bonus, `test_must_fail` will now only run on git
commands.
Signed-off-by: Denton Liu <liu.denton@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-06-24 10:50:18 +02:00
|
|
|
may_only_be_test_must_fail "$2" &&
|
|
|
|
$2 git pull --ff
|
2014-06-15 19:02:47 +02:00
|
|
|
}
|
|
|
|
|
2020-06-11 19:41:49 +02:00
|
|
|
test_submodule_switch_func "git_pull_ff"
|
2014-06-15 19:02:47 +02:00
|
|
|
|
|
|
|
git_pull_ff_only () {
|
|
|
|
reset_branch_to_HEAD "$1" &&
|
lib-submodule-update: pass 'test_must_fail' as an argument
When we run a test helper function in test_submodule_switch_common(), we
sometimes specify a whole helper function as the $command. When we do
this, in some test cases, we just mark the whole function with
`test_must_fail`. However, it's possible that the helper function might
fail earlier or later than expected due to an introduced bug. If this
happens, then the test case will still report as passing but it should
really be marked as failing since it didn't actually display the
intended behaviour.
Instead of invoking `test_must_fail $command`, pass the string
"test_must_fail" as the second argument in case where the git command is
expected to fail.
When $command is a helper function, the parent function calling
test_submodule_switch_common() is test_submodule_switch_func(). For all
test_submodule_switch_func() invocations, increase the granularity of
the argument test helper function by prefixing the git invocation which is
meant to fail with the second argument like this:
$2 git checkout "$1"
In the other cases, test_submodule_switch() and
test_submodule_forced_switch(), instead of passing in the git command
directly, wrap it using the git_test_func() and pass the git arguments
using the global variable $gitcmd. Unfortunately, since closures aren't
a thing in shell scripts, the global variable is necessary. Another
unfortunate result is that the "git_test_func" will used as the test
case name when $command is printed but it's worth it for the cleaner
code.
Finally, as an added bonus, `test_must_fail` will now only run on git
commands.
Signed-off-by: Denton Liu <liu.denton@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-06-24 10:50:18 +02:00
|
|
|
may_only_be_test_must_fail "$2" &&
|
|
|
|
$2 git pull --ff-only
|
2014-06-15 19:02:47 +02:00
|
|
|
}
|
|
|
|
|
2020-06-11 19:41:49 +02:00
|
|
|
test_submodule_switch_func "git_pull_ff_only"
|
2014-06-15 19:02:47 +02:00
|
|
|
|
|
|
|
git_pull_noff () {
|
|
|
|
reset_branch_to_HEAD "$1" &&
|
lib-submodule-update: pass 'test_must_fail' as an argument
When we run a test helper function in test_submodule_switch_common(), we
sometimes specify a whole helper function as the $command. When we do
this, in some test cases, we just mark the whole function with
`test_must_fail`. However, it's possible that the helper function might
fail earlier or later than expected due to an introduced bug. If this
happens, then the test case will still report as passing but it should
really be marked as failing since it didn't actually display the
intended behaviour.
Instead of invoking `test_must_fail $command`, pass the string
"test_must_fail" as the second argument in case where the git command is
expected to fail.
When $command is a helper function, the parent function calling
test_submodule_switch_common() is test_submodule_switch_func(). For all
test_submodule_switch_func() invocations, increase the granularity of
the argument test helper function by prefixing the git invocation which is
meant to fail with the second argument like this:
$2 git checkout "$1"
In the other cases, test_submodule_switch() and
test_submodule_forced_switch(), instead of passing in the git command
directly, wrap it using the git_test_func() and pass the git arguments
using the global variable $gitcmd. Unfortunately, since closures aren't
a thing in shell scripts, the global variable is necessary. Another
unfortunate result is that the "git_test_func" will used as the test
case name when $command is printed but it's worth it for the cleaner
code.
Finally, as an added bonus, `test_must_fail` will now only run on git
commands.
Signed-off-by: Denton Liu <liu.denton@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-06-24 10:50:18 +02:00
|
|
|
may_only_be_test_must_fail "$2" &&
|
|
|
|
$2 git pull --no-ff
|
2014-06-15 19:02:47 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
KNOWN_FAILURE_NOFF_MERGE_DOESNT_CREATE_EMPTY_SUBMODULE_DIR=1
|
|
|
|
KNOWN_FAILURE_NOFF_MERGE_ATTEMPTS_TO_MERGE_REMOVED_SUBMODULE_FILES=1
|
2020-06-11 19:41:49 +02:00
|
|
|
test_submodule_switch_func "git_pull_noff"
|
2014-06-15 19:02:47 +02:00
|
|
|
|
pull: optionally rebase submodules (remote submodule changes only)
Teach pull to optionally update submodules when '--recurse-submodules'
is provided. This will teach pull to run 'submodule update --rebase'
when the '--recurse-submodules' and '--rebase' flags are given under
specific circumstances.
On a rebase workflow:
=====================
1. Both sides change the submodule
------------------------------
Let's assume the following history in a submodule:
H---I---J---K---L local branch
\
M---N---O---P remote branch
and the following in the superproject (recorded submodule in parens):
A(H)---B(I)---F(K)---G(L) local branch
\
C(N)---D(N)---E(P) remote branch
In an ideal world this would rebase the submodule and rewrite
the submodule pointers that the superproject points at such that
the superproject looks like
A(H)---B(I) F(K')---G(L') rebased branch
\ /
C(N)---D(N)---E(P) remote branch
and the submodule as:
J---K---L (old dangeling tip)
/
H---I J'---K'---L' rebased branch
\ /
M---N---O---P remote branch
And if a conflict arises in the submodule the superproject rebase
would stop at that commit at which the submodule conflict occurs.
Currently a "pull --rebase" in the superproject produces
a merge conflict as the submodule pointer changes are
conflicting and cannot be resolved.
2. Local submodule changes only
-----------------------
Assuming histories as above, except that the remote branch
would not contain submodule changes, then a result as
A(H)---B(I) F(K)---G(L) rebased branch
\ /
C(I)---D(I)---E(I) remote branch
is desire-able. This is what currently happens in rebase.
If the recursive flag is given, the ideal git would
produce a superproject as:
A(H)---B(I) F(K')---G(L') rebased branch (incl. sub rebase!)
\ /
C(I)---D(I)---E(I) remote branch
and the submodule as:
J---K---L (old dangeling tip)
/
H---I J'---K'---L' locally rebased branch
\ /
M---N---O---P advanced branch
This patch doesn't address this issue, however
a test is added that this fails up front.
3. Remote submodule changes only
----------------------
Assuming histories as in (1) except that the local superproject branch
would not have touched the submodule the rebase already works out in the
superproject with no conflicts:
A(H)---B(I) F(P)---G(P) rebased branch (no sub changes)
\ /
C(N)---D(N)---E(P) remote branch
The recurse flag as presented in this patch would additionally
update the submodule as:
H---I J'---K'---L' rebased branch
\ /
M---N---O---P remote branch
As neither J, K, L nor J', K', L' are referred to from the superproject,
no rewriting of the superproject commits is required.
Conclusion for 'pull --rebase --recursive'
-----------------------------------------
If there are no local superproject changes it is sufficient to call
"submodule update --rebase" as this produces the desired results. In case
of conflicts, the behavior is the same as in 'submodule update --recursive'
which is assumed to be sane.
This patch implements (3) only.
On a merge workflow:
====================
We'll start off with the same underlying DAG as in (1) in the rebase
workflow. So in an ideal world a 'pull --merge --recursive' would
produce this:
H---I---J---K---L----X
\ /
M---N---O---P
with X as the new merge-commit in the submodule and the superproject
as:
A(H)---B(I)---F(K)---G(L)---Y(X)
\ /
C(N)---D(N)---E(P)
However modifying the submodules on the fly is not supported in git-merge
such that Y(X) is not easy to produce in a single patch. In fact git-merge
doesn't know about submodules at all.
However when at least one side does not contain commits touching the
submodule at all, then we do not need to perform the merge for the
submodule but a fast-forward can be done via checking out either L or P
in the submodule. This strategy is implemented in 68d03e4a6e (Implement
automatic fast-forward merge for submodules, 2010-07-07) already, so
to align with the rebase behavior we need to also update the worktree
of the submodule.
Signed-off-by: Brandon Williams <bmwill@google.com>
Signed-off-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-06-23 21:13:02 +02:00
|
|
|
test_expect_success 'pull --recurse-submodule setup' '
|
|
|
|
test_create_repo child &&
|
|
|
|
test_commit -C child bar &&
|
|
|
|
|
|
|
|
test_create_repo parent &&
|
|
|
|
test_commit -C child foo &&
|
|
|
|
|
|
|
|
git -C parent submodule add ../child sub &&
|
|
|
|
git -C parent commit -m "add submodule" &&
|
|
|
|
|
|
|
|
git clone --recurse-submodules parent super
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'recursive pull updates working tree' '
|
|
|
|
test_commit -C child merge_strategy &&
|
|
|
|
git -C parent submodule update --remote &&
|
|
|
|
git -C parent add sub &&
|
|
|
|
git -C parent commit -m "update submodule" &&
|
|
|
|
|
|
|
|
git -C super pull --no-rebase --recurse-submodules &&
|
|
|
|
test_path_is_file super/sub/merge_strategy.t
|
|
|
|
'
|
|
|
|
|
2017-09-06 08:48:09 +02:00
|
|
|
test_expect_success "submodule.recurse option triggers recursive pull" '
|
|
|
|
test_commit -C child merge_strategy_2 &&
|
|
|
|
git -C parent submodule update --remote &&
|
|
|
|
git -C parent add sub &&
|
|
|
|
git -C parent commit -m "update submodule" &&
|
|
|
|
|
|
|
|
git -C super -c submodule.recurse pull --no-rebase &&
|
|
|
|
test_path_is_file super/sub/merge_strategy_2.t
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success " --[no-]recurse-submodule and submodule.recurse" '
|
|
|
|
test_commit -C child merge_strategy_3 &&
|
|
|
|
git -C parent submodule update --remote &&
|
|
|
|
git -C parent add sub &&
|
|
|
|
git -C parent commit -m "update submodule" &&
|
|
|
|
|
|
|
|
git -C super -c submodule.recurse pull --no-recurse-submodules --no-rebase &&
|
|
|
|
test_path_is_missing super/sub/merge_strategy_3.t &&
|
|
|
|
git -C super -c submodule.recurse=false pull --recurse-submodules --no-rebase &&
|
|
|
|
test_path_is_file super/sub/merge_strategy_3.t &&
|
|
|
|
|
|
|
|
test_commit -C child merge_strategy_4 &&
|
|
|
|
git -C parent submodule update --remote &&
|
|
|
|
git -C parent add sub &&
|
|
|
|
git -C parent commit -m "update submodule" &&
|
|
|
|
|
|
|
|
git -C super -c submodule.recurse=false pull --no-recurse-submodules --no-rebase &&
|
|
|
|
test_path_is_missing super/sub/merge_strategy_4.t &&
|
|
|
|
git -C super -c submodule.recurse=true pull --recurse-submodules --no-rebase &&
|
|
|
|
test_path_is_file super/sub/merge_strategy_4.t
|
|
|
|
'
|
|
|
|
|
pull: optionally rebase submodules (remote submodule changes only)
Teach pull to optionally update submodules when '--recurse-submodules'
is provided. This will teach pull to run 'submodule update --rebase'
when the '--recurse-submodules' and '--rebase' flags are given under
specific circumstances.
On a rebase workflow:
=====================
1. Both sides change the submodule
------------------------------
Let's assume the following history in a submodule:
H---I---J---K---L local branch
\
M---N---O---P remote branch
and the following in the superproject (recorded submodule in parens):
A(H)---B(I)---F(K)---G(L) local branch
\
C(N)---D(N)---E(P) remote branch
In an ideal world this would rebase the submodule and rewrite
the submodule pointers that the superproject points at such that
the superproject looks like
A(H)---B(I) F(K')---G(L') rebased branch
\ /
C(N)---D(N)---E(P) remote branch
and the submodule as:
J---K---L (old dangeling tip)
/
H---I J'---K'---L' rebased branch
\ /
M---N---O---P remote branch
And if a conflict arises in the submodule the superproject rebase
would stop at that commit at which the submodule conflict occurs.
Currently a "pull --rebase" in the superproject produces
a merge conflict as the submodule pointer changes are
conflicting and cannot be resolved.
2. Local submodule changes only
-----------------------
Assuming histories as above, except that the remote branch
would not contain submodule changes, then a result as
A(H)---B(I) F(K)---G(L) rebased branch
\ /
C(I)---D(I)---E(I) remote branch
is desire-able. This is what currently happens in rebase.
If the recursive flag is given, the ideal git would
produce a superproject as:
A(H)---B(I) F(K')---G(L') rebased branch (incl. sub rebase!)
\ /
C(I)---D(I)---E(I) remote branch
and the submodule as:
J---K---L (old dangeling tip)
/
H---I J'---K'---L' locally rebased branch
\ /
M---N---O---P advanced branch
This patch doesn't address this issue, however
a test is added that this fails up front.
3. Remote submodule changes only
----------------------
Assuming histories as in (1) except that the local superproject branch
would not have touched the submodule the rebase already works out in the
superproject with no conflicts:
A(H)---B(I) F(P)---G(P) rebased branch (no sub changes)
\ /
C(N)---D(N)---E(P) remote branch
The recurse flag as presented in this patch would additionally
update the submodule as:
H---I J'---K'---L' rebased branch
\ /
M---N---O---P remote branch
As neither J, K, L nor J', K', L' are referred to from the superproject,
no rewriting of the superproject commits is required.
Conclusion for 'pull --rebase --recursive'
-----------------------------------------
If there are no local superproject changes it is sufficient to call
"submodule update --rebase" as this produces the desired results. In case
of conflicts, the behavior is the same as in 'submodule update --recursive'
which is assumed to be sane.
This patch implements (3) only.
On a merge workflow:
====================
We'll start off with the same underlying DAG as in (1) in the rebase
workflow. So in an ideal world a 'pull --merge --recursive' would
produce this:
H---I---J---K---L----X
\ /
M---N---O---P
with X as the new merge-commit in the submodule and the superproject
as:
A(H)---B(I)---F(K)---G(L)---Y(X)
\ /
C(N)---D(N)---E(P)
However modifying the submodules on the fly is not supported in git-merge
such that Y(X) is not easy to produce in a single patch. In fact git-merge
doesn't know about submodules at all.
However when at least one side does not contain commits touching the
submodule at all, then we do not need to perform the merge for the
submodule but a fast-forward can be done via checking out either L or P
in the submodule. This strategy is implemented in 68d03e4a6e (Implement
automatic fast-forward merge for submodules, 2010-07-07) already, so
to align with the rebase behavior we need to also update the worktree
of the submodule.
Signed-off-by: Brandon Williams <bmwill@google.com>
Signed-off-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-06-23 21:13:02 +02:00
|
|
|
test_expect_success 'recursive rebasing pull' '
|
|
|
|
# change upstream
|
|
|
|
test_commit -C child rebase_strategy &&
|
|
|
|
git -C parent submodule update --remote &&
|
|
|
|
git -C parent add sub &&
|
|
|
|
git -C parent commit -m "update submodule" &&
|
|
|
|
|
|
|
|
# also have local commits
|
|
|
|
test_commit -C super/sub local_stuff &&
|
|
|
|
|
|
|
|
git -C super pull --rebase --recurse-submodules &&
|
|
|
|
test_path_is_file super/sub/rebase_strategy.t &&
|
|
|
|
test_path_is_file super/sub/local_stuff.t
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'pull rebase recursing fails with conflicts' '
|
|
|
|
|
|
|
|
# local changes in submodule recorded in superproject:
|
|
|
|
test_commit -C super/sub local_stuff_2 &&
|
|
|
|
git -C super add sub &&
|
|
|
|
git -C super commit -m "local update submodule" &&
|
|
|
|
|
|
|
|
# and in the remote as well:
|
|
|
|
test_commit -C child important_upstream_work &&
|
|
|
|
git -C parent submodule update --remote &&
|
|
|
|
git -C parent add sub &&
|
|
|
|
git -C parent commit -m "remote update submodule" &&
|
|
|
|
|
|
|
|
# Unfortunately we fail here, despite no conflict in the
|
|
|
|
# submodule itself, but the merge strategy in submodules
|
|
|
|
# does not support rebase:
|
|
|
|
test_must_fail git -C super pull --rebase --recurse-submodules 2>err &&
|
|
|
|
test_i18ngrep "locally recorded submodule modifications" err
|
|
|
|
'
|
|
|
|
|
2018-05-24 22:47:29 +02:00
|
|
|
test_expect_success 'branch has no merge base with remote-tracking counterpart' '
|
|
|
|
rm -rf parent child &&
|
|
|
|
|
|
|
|
test_create_repo a-submodule &&
|
|
|
|
test_commit -C a-submodule foo &&
|
|
|
|
|
|
|
|
test_create_repo parent &&
|
|
|
|
git -C parent submodule add "$(pwd)/a-submodule" &&
|
|
|
|
git -C parent commit -m foo &&
|
|
|
|
|
|
|
|
git clone parent child &&
|
|
|
|
|
|
|
|
# Reset master so that it has no merge base with
|
|
|
|
# refs/remotes/origin/master.
|
|
|
|
OTHER=$(git -C child commit-tree -m bar \
|
|
|
|
$(git -C child rev-parse HEAD^{tree})) &&
|
|
|
|
git -C child reset --hard "$OTHER" &&
|
|
|
|
|
|
|
|
git -C child pull --recurse-submodules --rebase
|
|
|
|
'
|
|
|
|
|
2014-06-15 19:02:47 +02:00
|
|
|
test_done
|