wehub-resource-sync
1497 lines
47 KiB
Bash
Executable File
1497 lines
47 KiB
Bash
Executable File
#!/usr/bin/env bats
|
|
load $BATS_TEST_DIRNAME/helper/common.bash
|
|
|
|
setup() {
|
|
setup_common
|
|
}
|
|
|
|
teardown() {
|
|
teardown_common
|
|
}
|
|
|
|
export NO_COLOR=1
|
|
|
|
@test "checkout: dolt checkout takes working set changes with you" {
|
|
dolt sql <<SQL
|
|
create table test(a int primary key);
|
|
insert into test values (1);
|
|
SQL
|
|
dolt add .
|
|
|
|
dolt commit -am "Initial table with one row"
|
|
dolt branch feature
|
|
|
|
dolt sql -q "insert into test values (2)"
|
|
dolt checkout feature
|
|
|
|
run dolt sql -q "select count(*) from test"
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "2" ]] || false
|
|
|
|
run dolt status
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "modified" ]] || false
|
|
|
|
dolt checkout main
|
|
|
|
run dolt sql -q "select count(*) from test"
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "2" ]] || false
|
|
|
|
run dolt status
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "modified" ]] || false
|
|
|
|
# Making additional changes to main, should carry them to feature without any problem
|
|
dolt sql -q "insert into test values (3)"
|
|
dolt checkout feature
|
|
|
|
run dolt sql -q "select count(*) from test"
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "3" ]] || false
|
|
|
|
run dolt status
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "modified" ]] || false
|
|
}
|
|
|
|
@test "checkout: dolt checkout takes working set changes with you on new table" {
|
|
dolt sql <<SQL
|
|
create table test(a int primary key);
|
|
insert into test values (1);
|
|
SQL
|
|
dolt add . && dolt commit -am "Initial table with one row"
|
|
dolt branch feature
|
|
|
|
dolt sql -q "create table t2(b int primary key)"
|
|
dolt sql -q "insert into t2 values (1);"
|
|
|
|
# This is fine for an untracked table, takes it to the new branch with you
|
|
dolt checkout feature
|
|
|
|
run dolt sql -q "select count(*) from t2"
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "1" ]] || false
|
|
|
|
run dolt status
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "new table" ]] || false
|
|
|
|
dolt checkout main
|
|
|
|
run dolt sql -q "select count(*) from t2"
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "1" ]] || false
|
|
|
|
run dolt status
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "new table" ]] || false
|
|
|
|
# Now check the table into main and make additional changes
|
|
dolt add . && dolt commit -m "new table"
|
|
dolt sql -q "insert into t2 values (2);"
|
|
|
|
# This is an error, matching git (cannot check out a branch that lacks a
|
|
# file you have modified)
|
|
run dolt checkout feature
|
|
[ "$status" -ne 0 ]
|
|
[[ "$output" =~ "Your local changes to the following tables would be overwritten by checkout" ]] || false
|
|
[[ "$output" =~ "t2" ]] || false
|
|
}
|
|
|
|
@test "checkout: checkout would overwrite local changes" {
|
|
dolt sql <<SQL
|
|
create table test(a int primary key);
|
|
insert into test values (1);
|
|
SQL
|
|
dolt add .
|
|
|
|
dolt commit -am "Initial table with one row"
|
|
dolt checkout -b feature
|
|
|
|
dolt sql -q "insert into test values (2)"
|
|
dolt commit -am "inserted a value"
|
|
dolt checkout main
|
|
|
|
dolt sql -q "insert into test values (3)"
|
|
run dolt checkout feature
|
|
|
|
[ "$status" -ne 0 ]
|
|
[[ "$output" =~ "Your local changes to the following tables would be overwritten by checkout" ]] || false
|
|
[[ "$output" =~ "test" ]] || false
|
|
}
|
|
|
|
@test "checkout: dolt checkout doesn't stomp working set changes on other branch" {
|
|
dolt sql <<SQL
|
|
create table test(a int primary key);
|
|
insert into test values (1);
|
|
SQL
|
|
|
|
dolt add .
|
|
dolt commit -am "Initial table with one row"
|
|
dolt branch feature
|
|
|
|
dolt sql <<SQL
|
|
call dolt_checkout('feature');
|
|
insert into test values (2);
|
|
SQL
|
|
|
|
# With no uncommitted working set changes, this works fine (no
|
|
# working set comes with us, we get the working set of the feature
|
|
# branch instead)
|
|
run dolt checkout feature
|
|
[ "$status" -eq 0 ]
|
|
|
|
run dolt sql -q "select count(*) from test"
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "2" ]] || false
|
|
|
|
# These working set changes come with us when we change back to main
|
|
dolt checkout main
|
|
run dolt sql -q "select count(*) from test"
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "2" ]] || false
|
|
|
|
# Reset our test setup
|
|
dolt sql <<SQL
|
|
call dolt_checkout('feature');
|
|
call dolt_reset('--hard');
|
|
insert into test values (3);
|
|
SQL
|
|
|
|
# With a dirty working set on the other branch, dolt checkout should fail
|
|
run dolt checkout feature
|
|
[ "$status" -eq 1 ]
|
|
[[ "$output" =~ "checkout would overwrite uncommitted changes" ]] || false
|
|
|
|
# Same as above, but changes are staged, not in working
|
|
dolt sql <<SQL
|
|
call dolt_checkout('feature');
|
|
call dolt_reset('--hard');
|
|
insert into test values (3);
|
|
call dolt_add('.');
|
|
SQL
|
|
|
|
run dolt checkout feature
|
|
[ "$status" -eq 1 ]
|
|
[[ "$output" =~ "checkout would overwrite uncommitted changes" ]] || false
|
|
|
|
# Same as above, but changes are staged and working
|
|
dolt add .
|
|
dolt sql <<SQL
|
|
call dolt_checkout('feature');
|
|
call dolt_reset('--hard');
|
|
insert into test values (3);
|
|
call dolt_add('.');
|
|
insert into test values (4);
|
|
SQL
|
|
|
|
run dolt checkout feature
|
|
[ "$status" -eq 1 ]
|
|
[[ "$output" =~ "checkout would overwrite uncommitted changes" ]] || false
|
|
|
|
dolt reset --hard
|
|
dolt sql -q "insert into test values (3)"
|
|
dolt add .
|
|
dolt sql -q "insert into test values (4)"
|
|
|
|
# with staged changes matching on both branches, permit the checkout
|
|
dolt checkout feature
|
|
run dolt sql -q "select count(*) from test"
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "3" ]] || false
|
|
}
|
|
|
|
@test "checkout: dolt checkout table to restore working tree tables with add and drop foreign key" {
|
|
dolt sql -q "create table t (c1 int primary key, c2 int, check(c2 > 0))"
|
|
dolt sql -q "create table z (c1 int primary key, c2 int)"
|
|
dolt commit -Am "create tables t and z"
|
|
|
|
dolt sql -q "ALTER TABLE z ADD CONSTRAINT foreign_key1 FOREIGN KEY (c1) references t(c1)"
|
|
run dolt status
|
|
[[ "$output" =~ "Changes not staged for commit:" ]] || false
|
|
[[ "$output" =~ "modified: z" ]] || false
|
|
|
|
run dolt schema show z
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "foreign_key1" ]] || false
|
|
|
|
dolt checkout z
|
|
|
|
run dolt status
|
|
[[ "$output" =~ "On branch main" ]] || false
|
|
[[ "$output" =~ "nothing to commit, working tree clean" ]] || false
|
|
|
|
run dolt schema show z
|
|
[ "$status" -eq 0 ]
|
|
[[ ! "$output" =~ "foreign_key1" ]] || false
|
|
|
|
dolt sql -q "ALTER TABLE z ADD CONSTRAINT foreign_key1 FOREIGN KEY (c1) references t(c1)"
|
|
dolt commit -am "add fkey"
|
|
|
|
dolt sql -q "alter table z drop constraint foreign_key1"
|
|
run dolt status
|
|
[[ "$output" =~ "Changes not staged for commit:" ]] || false
|
|
[[ "$output" =~ "modified: z" ]] || false
|
|
|
|
run dolt schema show z
|
|
[ "$status" -eq 0 ]
|
|
[[ ! "$output" =~ "foreign_key1" ]] || false
|
|
|
|
dolt checkout z
|
|
|
|
run dolt status
|
|
[[ "$output" =~ "On branch main" ]] || false
|
|
[[ "$output" =~ "nothing to commit, working tree clean" ]] || false
|
|
|
|
run dolt schema show z
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "foreign_key1" ]] || false
|
|
}
|
|
|
|
@test "checkout: dolt checkout table from another branch" {
|
|
dolt sql -q "create table t (c1 int primary key, c2 int, check(c2 > 0))"
|
|
dolt sql -q "create table z (c1 int primary key, c2 int)"
|
|
dolt sql -q "insert into t values (1,1)"
|
|
dolt sql -q "insert into z values (2,2);"
|
|
dolt commit -Am "new values in t"
|
|
dolt branch b1
|
|
dolt sql -q "insert into t values (3,3);"
|
|
dolt sql -q "insert into z values (4,4);"
|
|
dolt checkout b1 -- t
|
|
|
|
dolt status
|
|
run dolt status
|
|
[[ "$output" =~ "On branch main" ]] || false
|
|
[[ "$output" =~ "modified: z" ]] || false
|
|
[[ ! "$output" =~ "modified: t" ]] || false
|
|
|
|
run dolt sql -q "select count(*) from t" -r csv
|
|
[[ "$output" =~ "1" ]] || false
|
|
|
|
run dolt sql -q "select count(*) from z" -r csv
|
|
[[ "$output" =~ "2" ]] || false
|
|
}
|
|
|
|
@test "checkout: with -f flag without conflict" {
|
|
dolt sql -q 'create table test (id int primary key);'
|
|
dolt sql -q 'insert into test (id) values (8);'
|
|
dolt add .
|
|
dolt commit -m 'create test table.'
|
|
|
|
dolt checkout -b branch1
|
|
dolt sql -q 'insert into test (id) values (1), (2), (3);'
|
|
dolt add .
|
|
dolt commit -m 'add some values to branch 1.'
|
|
|
|
run dolt checkout -f main
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "Switched to branch 'main'" ]] || false
|
|
|
|
run dolt sql -q "select * from test;"
|
|
[[ "$output" =~ "8" ]] || false
|
|
[[ ! "$output" =~ "1" ]] || false
|
|
[[ ! "$output" =~ "2" ]] || false
|
|
[[ ! "$output" =~ "3" ]] || false
|
|
|
|
dolt checkout branch1
|
|
run dolt sql -q "select * from test;"
|
|
[[ "$output" =~ "1" ]] || false
|
|
[[ "$output" =~ "2" ]] || false
|
|
[[ "$output" =~ "3" ]] || false
|
|
[[ "$output" =~ "8" ]] || false
|
|
}
|
|
|
|
@test "checkout: with -f flag with conflict" {
|
|
dolt sql -q 'create table test (id int primary key);'
|
|
dolt sql -q 'insert into test (id) values (8);'
|
|
dolt add .
|
|
dolt commit -m 'create test table.'
|
|
|
|
dolt checkout -b branch1
|
|
dolt sql -q 'insert into test (id) values (1), (2), (3);'
|
|
dolt add .
|
|
dolt commit -m 'add some values to branch 1.'
|
|
|
|
dolt sql -q 'insert into test (id) values (4);'
|
|
run dolt checkout main
|
|
[ "$status" -eq 1 ]
|
|
[[ "$output" =~ "Please commit your changes or stash them before you switch branches." ]] || false
|
|
|
|
# Still on main
|
|
run dolt status
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "branch1" ]] || false
|
|
|
|
run dolt checkout -f main
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "Switched to branch 'main'" ]] || false
|
|
|
|
run dolt sql -q "select * from test;"
|
|
[[ "$output" =~ "8" ]] || false
|
|
[[ ! "$output" =~ "4" ]] || false
|
|
|
|
dolt checkout branch1
|
|
run dolt sql -q "select * from test;"
|
|
[[ "$output" =~ "1" ]] || false
|
|
[[ "$output" =~ "2" ]] || false
|
|
[[ "$output" =~ "3" ]] || false
|
|
[[ "$output" =~ "8" ]] || false
|
|
[[ ! "$output" =~ "4" ]] || false
|
|
}
|
|
|
|
@test "checkout: -B flag will forcefully reset an existing branch" {
|
|
dolt sql -q 'create table test (id int primary key);'
|
|
dolt sql -q 'insert into test (id) values (89012);'
|
|
dolt commit -Am 'first change.'
|
|
dolt sql -q 'insert into test (id) values (76543);'
|
|
dolt commit -Am 'second change.'
|
|
|
|
dolt checkout -b testbr main~1
|
|
run dolt sql -q "select * from test;"
|
|
[[ "$output" =~ "89012" ]] || false
|
|
[[ ! "$output" =~ "76543" ]] || false
|
|
|
|
# make a change to the branch which we'll lose
|
|
dolt sql -q 'insert into test (id) values (19283);'
|
|
dolt commit -Am 'change to testbr.'
|
|
|
|
dolt checkout main
|
|
dolt checkout -B testbr main
|
|
run dolt sql -q "select * from test;"
|
|
[[ "$output" =~ "89012" ]] || false
|
|
[[ "$output" =~ "76543" ]] || false
|
|
[[ ! "$output" =~ "19283" ]] || false
|
|
}
|
|
|
|
@test "checkout: -B will create a branch that does not exist" {
|
|
dolt sql -q 'create table test (id int primary key);'
|
|
dolt sql -q 'insert into test (id) values (89012);'
|
|
dolt commit -Am 'first change.'
|
|
dolt sql -q 'insert into test (id) values (76543);'
|
|
dolt commit -Am 'second change.'
|
|
|
|
dolt checkout -B testbr main~1
|
|
run dolt sql -q "select * from test;"
|
|
[[ "$output" =~ "89012" ]] || false
|
|
[[ ! "$output" =~ "76543" ]] || false
|
|
}
|
|
|
|
@test "checkout: attempting to checkout a detached head shows a suggestion instead" {
|
|
dolt sql -q "create table test (id int primary key);"
|
|
dolt add .
|
|
dolt commit -m "create test table."
|
|
sha=$(dolt log --oneline --decorate=no | head -n 1 | cut -d ' ' -f 1)
|
|
|
|
# remove special characters (color)
|
|
sha=$(echo $sha | sed -E "s/[[:cntrl:]]\[[0-9]{1,3}m//g")
|
|
|
|
run dolt checkout "$sha"
|
|
[ "$status" -ne 0 ]
|
|
cmd=$(echo "${lines[1]}" | cut -d ' ' -f 1,2,3)
|
|
[[ $cmd =~ "dolt checkout $sha" ]] || false
|
|
}
|
|
|
|
@test "checkout: commit --amend only changes commit message" {
|
|
dolt sql -q "create table test (id int primary key);"
|
|
dolt sql -q 'insert into test (id) values (8);'
|
|
dolt add .
|
|
dolt commit -m "original commit message"
|
|
|
|
dolt commit --amend -m "modified_commit_message"
|
|
|
|
commitmsg=$(dolt log --oneline | head -n 1)
|
|
[[ $commitmsg =~ "modified_commit_message" ]] || false
|
|
|
|
numcommits=$(dolt log --oneline | wc -l)
|
|
[[ $numcommits =~ "2" ]] || false
|
|
|
|
run dolt sql -q 'select * from test;'
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "8" ]] || false
|
|
}
|
|
|
|
@test "checkout: commit --amend adds new changes to existing commit" {
|
|
dolt sql -q "create table test (id int primary key);"
|
|
dolt sql -q 'insert into test (id) values (8);'
|
|
dolt add .
|
|
dolt commit -m "original commit message"
|
|
|
|
dolt sql -q 'insert into test (id) values (9);'
|
|
dolt add .
|
|
dolt commit --amend -m "modified_commit_message"
|
|
|
|
commitmsg=$(dolt log --oneline | head -n 1)
|
|
[[ $commitmsg =~ "modified_commit_message" ]] || false
|
|
|
|
numcommits=$(dolt log --oneline | wc -l)
|
|
[[ $numcommits =~ "2" ]] || false
|
|
|
|
run dolt sql -q 'select * from test;'
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "8" ]] || false
|
|
[[ "$output" =~ "9" ]] || false
|
|
}
|
|
|
|
@test "checkout: commit --amend on merge commits does not modify metadata of merged parents" {
|
|
dolt sql -q "create table test (id int primary key, id2 int);"
|
|
dolt add .
|
|
dolt commit -m "original table"
|
|
|
|
dolt checkout -b test-branch
|
|
dolt sql -q 'insert into test (id, id2) values (0, 2);'
|
|
dolt add .
|
|
dolt commit -m "conflicting commit message"
|
|
|
|
shaparent1=$(dolt log --oneline --decorate=no | head -n 1 | cut -d ' ' -f 1)
|
|
# remove special characters (color)
|
|
shaparent1=$(echo $shaparent1 | sed -E "s/[[:cntrl:]]\[[0-9]{1,3}m//g")
|
|
|
|
dolt checkout main
|
|
dolt sql -q 'insert into test (id, id2) values (0, 1);'
|
|
dolt add .
|
|
dolt commit -m "original commit message"
|
|
shaparent2=$(dolt log --oneline --decorate=no | head -n 1 | cut -d ' ' -f 1)
|
|
# remove special characters (color)
|
|
shaparent2=$(echo $shaparent2 | sed -E "s/[[:cntrl:]]\[[0-9]{1,3}m//g")
|
|
|
|
run dolt merge test-branch
|
|
[ "$status" -eq 1 ]
|
|
[[ "$output" =~ "CONFLICT (content):" ]] || false
|
|
dolt conflicts resolve --theirs .
|
|
dolt commit -m "final merge"
|
|
|
|
dolt commit --amend -m "new merge"
|
|
commitmeta=$(dolt log --oneline --parents | head -n 1)
|
|
[[ "$commitmeta" =~ "$shaparent1" ]] || false
|
|
[[ "$commitmeta" =~ "$shaparent2" ]] || false
|
|
}
|
|
|
|
@test "checkout: dolt_commit --amend on merge commits does not modify metadata of merged parents" {
|
|
dolt sql -q "create table test (id int primary key, id2 int);"
|
|
dolt add .
|
|
dolt commit -m "original table"
|
|
|
|
dolt checkout -b test-branch
|
|
dolt sql -q 'insert into test (id, id2) values (0, 2);'
|
|
dolt add .
|
|
dolt commit -m "conflicting commit message"
|
|
|
|
shaparent1=$(dolt log --oneline --decorate=no | head -n 1 | cut -d ' ' -f 1)
|
|
# remove special characters (color)
|
|
shaparent1=$(echo $shaparent1 | sed -E "s/[[:cntrl:]]\[[0-9]{1,3}m//g")
|
|
|
|
dolt checkout main
|
|
dolt sql -q 'insert into test (id, id2) values (0, 1);'
|
|
dolt add .
|
|
dolt commit -m "original commit message"
|
|
shaparent2=$(dolt log --oneline --decorate=no | head -n 1 | cut -d ' ' -f 1)
|
|
# remove special characters (color)
|
|
shaparent2=$(echo $shaparent2 | sed -E "s/[[:cntrl:]]\[[0-9]{1,3}m//g")
|
|
|
|
run dolt merge test-branch
|
|
[ "$status" -eq 1 ]
|
|
echo "$output"
|
|
[[ "$output" =~ "CONFLICT (content):" ]] || false
|
|
dolt conflicts resolve --theirs .
|
|
dolt commit -m "final merge"
|
|
|
|
dolt sql -q "call dolt_commit('--amend', '-m', 'new merge');"
|
|
commitmeta=$(dolt log --oneline --parents | head -n 1)
|
|
[[ "$commitmeta" =~ "$shaparent1" ]] || false
|
|
[[ "$commitmeta" =~ "$shaparent2" ]] || false
|
|
}
|
|
|
|
|
|
@test "checkout: dolt_checkout brings in changes from main to feature branch that has no working set" {
|
|
# original setup
|
|
dolt sql -q "create table users (id int primary key, name varchar(32));"
|
|
dolt add .
|
|
dolt commit -m "original users table"
|
|
|
|
# create feature branch
|
|
dolt branch -c main feature
|
|
|
|
# make changes on main and verify
|
|
dolt sql -q 'insert into users (id, name) values (1, "main-change");'
|
|
run dolt sql -q "select name from users"
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "main-change" ]] || false
|
|
|
|
# checkout feature branch and bring over main changes
|
|
dolt checkout feature
|
|
|
|
# verify working set changes are brought in from main
|
|
run dolt sql << SQL
|
|
call dolt_checkout('feature');
|
|
select name from users
|
|
SQL
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "main-change" ]] || false
|
|
|
|
# verify working set changes are not on main
|
|
run dolt sql << SQL
|
|
call dolt_checkout('main');
|
|
select count(*) from users
|
|
SQL
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "0" ]] || false
|
|
|
|
# revert working set changes on feature branch
|
|
dolt reset --hard HEAD
|
|
run dolt sql -q "select count(*) from users"
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "0" ]] || false
|
|
|
|
# switch to main and verify working set changes are not present
|
|
dolt checkout main
|
|
run dolt sql -q "select count(*) from users"
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "0" ]] || false
|
|
}
|
|
|
|
@test "checkout: dolt_checkout switches from clean main to feature branch that has changes" {
|
|
# original setup
|
|
dolt sql -q "create table users (id int primary key, name varchar(32));"
|
|
dolt add .
|
|
dolt commit -m "original users table"
|
|
|
|
# create feature branch
|
|
dolt branch -c main feature
|
|
|
|
# make changes on feature (through SQL)
|
|
dolt sql << SQL
|
|
call dolt_checkout('feature');
|
|
insert into users (id, name) values (1, "feature-change");
|
|
SQL
|
|
|
|
# verify feature branch changes are present
|
|
run dolt sql << SQL
|
|
call dolt_checkout('feature');
|
|
select name from users;
|
|
SQL
|
|
echo "output = $output"
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "feature-change" ]] || false
|
|
|
|
# checkout feature branch
|
|
dolt checkout feature
|
|
|
|
# verify feature's working set changes are gone
|
|
run dolt sql << SQL
|
|
call dolt_checkout('feature');
|
|
select count(*) from users
|
|
SQL
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "0" ]] || false
|
|
|
|
# verify working set changes are not on main
|
|
run dolt sql << SQL
|
|
call dolt_checkout('main');
|
|
select count(*) from users
|
|
SQL
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "0" ]] || false
|
|
}
|
|
|
|
@test "checkout: dolt_checkout brings in changes from main to feature branch that has identical changes" {
|
|
# original setup
|
|
dolt sql -q "create table users (id int primary key, name varchar(32));"
|
|
dolt add .
|
|
dolt commit -m "original users table"
|
|
|
|
# create feature branch
|
|
dolt branch -c main feature
|
|
|
|
# make changes on main and verify
|
|
dolt sql -q 'insert into users (id, name) values (1, "main-change");'
|
|
run dolt sql -q "select name from users"
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "main-change" ]] || false
|
|
|
|
# make identical changes on feature (through SQL)
|
|
dolt sql << SQL
|
|
call dolt_checkout('feature');
|
|
insert into users (id, name) values (1, "main-change");
|
|
SQL
|
|
|
|
# verify feature branch changes are present
|
|
run dolt sql << SQL
|
|
call dolt_checkout('feature');
|
|
select name from users;
|
|
SQL
|
|
echo "output = $output"
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "main-change" ]] || false
|
|
|
|
# checkout feature branch
|
|
dolt checkout feature
|
|
|
|
# verify working set changes are still the same on feature branch
|
|
run dolt sql << SQL
|
|
call dolt_checkout('feature');
|
|
select name from users
|
|
SQL
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "main-change" ]] || false
|
|
|
|
# verify working set changes are not on main
|
|
run dolt sql << SQL
|
|
call dolt_checkout('main');
|
|
select count(*) from users
|
|
SQL
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "0" ]] || false
|
|
|
|
# revert working set changes on feature branch
|
|
dolt reset --hard HEAD
|
|
|
|
# verify working set changes are not on feature branch
|
|
run dolt sql << SQL
|
|
call dolt_checkout('feature');
|
|
select count(*) from users
|
|
SQL
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "0" ]] || false
|
|
|
|
# switch to main and verify working set changes are not present
|
|
dolt checkout main
|
|
run dolt sql << SQL
|
|
call dolt_checkout('main');
|
|
select count(*) from users
|
|
SQL
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "0" ]] || false
|
|
}
|
|
|
|
@test "checkout: dolt_checkout needs -f to bring in changes from main to feature branch that has different changes" {
|
|
# original setup
|
|
dolt sql -q "create table users (id int primary key, name varchar(32));"
|
|
dolt add .
|
|
dolt commit -m "original users table"
|
|
|
|
# create feature branch from main
|
|
dolt branch feature
|
|
|
|
# make changes on main and verify
|
|
dolt sql -q 'insert into users (id, name) values (1, "main-change");'
|
|
run dolt sql -q "select name from users"
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "main-change" ]] || false
|
|
|
|
# make different changes on feature (through SQL)
|
|
dolt sql << SQL
|
|
call dolt_checkout('feature');
|
|
insert into users (id, name) values (2, "feature-change");
|
|
SQL
|
|
|
|
# verify feature branch changes are present
|
|
run dolt sql << SQL
|
|
call dolt_checkout('feature');
|
|
select name from users;
|
|
SQL
|
|
echo "output = $output"
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "feature-change" ]] || false
|
|
|
|
# checkout feature branch: should fail due to working set changes
|
|
run dolt checkout feature
|
|
echo "output = $output"
|
|
[ "$status" -eq 1 ]
|
|
[[ "$output" =~ "checkout would overwrite uncommitted changes on target branch" ]] || false
|
|
|
|
# force checkout feature branch
|
|
dolt checkout -f feature
|
|
|
|
# verify working set changes on feature are from main
|
|
run dolt sql << SQL
|
|
call dolt_checkout('feature');
|
|
select name from users
|
|
SQL
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "main-change" ]] || false
|
|
|
|
# verify working set changes are not on main
|
|
run dolt sql << SQL
|
|
call dolt_checkout('main');
|
|
select count(*) from users
|
|
SQL
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "0" ]] || false
|
|
}
|
|
|
|
@test "checkout: dolt_checkout brings changes from main to multiple feature branches and back to main" {
|
|
# original setup
|
|
dolt sql -q "create table users (id int primary key, name varchar(32));"
|
|
dolt add .
|
|
dolt commit -m "original users table"
|
|
|
|
|
|
# make changes on main and verify
|
|
dolt sql -q 'insert into users (id, name) values (0, "main-change");'
|
|
run dolt sql << SQL
|
|
call dolt_checkout('main');
|
|
select name from users
|
|
SQL
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "main-change" ]] || false
|
|
|
|
|
|
# create feature1 branch and bring changes to the new feature branch
|
|
dolt checkout -b feature1
|
|
|
|
# verify the changes are brought to feature1
|
|
run dolt sql << SQL
|
|
call dolt_checkout('feature1');
|
|
select name from users
|
|
SQL
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "main-change" ]] || false
|
|
|
|
|
|
# make changes on feature1 and verify
|
|
dolt sql -q 'insert into users (id, name) values (1, "feature1-change");'
|
|
run dolt sql << SQL
|
|
call dolt_checkout('feature1');
|
|
select name from users
|
|
SQL
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "main-change" ]] || false
|
|
[[ "$output" =~ "feature1-change" ]] || false
|
|
|
|
# create feature2 branch and bring changes to next feature branch
|
|
dolt checkout -b feature2
|
|
|
|
# verify the changes are brought to feature1
|
|
run dolt sql << SQL
|
|
call dolt_checkout('feature2');
|
|
select name from users
|
|
SQL
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "main-change" ]] || false
|
|
[[ "$output" =~ "feature1-change" ]] || false
|
|
|
|
# make changes on feature2 and verify
|
|
dolt sql -q 'insert into users (id, name) values (2, "feature2-change");'
|
|
run dolt sql << SQL
|
|
call dolt_checkout('feature2');
|
|
select name from users
|
|
SQL
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "main-change" ]] || false
|
|
[[ "$output" =~ "feature1-change" ]] || false
|
|
[[ "$output" =~ "feature2-change" ]] || false
|
|
|
|
|
|
# bring changes back to main
|
|
dolt checkout main
|
|
|
|
# verify the changes are brought to main
|
|
run dolt sql << SQL
|
|
call dolt_checkout('main');
|
|
select name from users
|
|
SQL
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "main-change" ]] || false
|
|
[[ "$output" =~ "feature1-change" ]] || false
|
|
[[ "$output" =~ "feature2-change" ]] || false
|
|
|
|
}
|
|
|
|
@test "checkout: table and branch name conflict with -- separator" {
|
|
# setup a table with the same name as a branch we'll create
|
|
dolt sql -q "create table feature (id int primary key, value int);"
|
|
dolt sql -q "insert into feature values (1, 100);"
|
|
dolt add .
|
|
dolt commit -m "Add feature table"
|
|
|
|
# create a branch with the same name as the table
|
|
dolt checkout -b feature
|
|
|
|
dolt sql -q "insert into feature values (2, 200);"
|
|
dolt add .
|
|
dolt commit -m "Add row to feature table"
|
|
|
|
dolt checkout main
|
|
|
|
# modify the feature table
|
|
dolt sql -q "update feature set value = 101 where id = 1;"
|
|
|
|
# use -- to explicitly indicate we want to checkout the table, not the branch
|
|
run dolt checkout -- feature
|
|
|
|
# verify the table was reset (not switched to feature branch)
|
|
run dolt sql -q "select * from feature;" -r csv
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "1,100" ]] || false
|
|
[[ ! "$output" =~ "101" ]] || false
|
|
|
|
# verify we're still on main branch
|
|
run dolt branch
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "* main" ]] || false
|
|
}
|
|
|
|
@test "checkout: explicit branch checkout with -- separator" {
|
|
# setup a table with the same name as a branch
|
|
dolt sql -q "create table feature (id int primary key, value int);"
|
|
dolt sql -q "insert into feature values (1, 100);"
|
|
dolt add .
|
|
dolt commit -m "Add feature table"
|
|
|
|
# create a branch with the same name as the table
|
|
dolt checkout -b feature
|
|
dolt sql -q "update feature set value = 200 where id = 1;"
|
|
dolt add .
|
|
dolt commit -m "Update feature value on feature branch"
|
|
|
|
dolt checkout main
|
|
|
|
# use explicit branch reference
|
|
dolt checkout feature --
|
|
|
|
# verify we switched to feature branch
|
|
run dolt branch
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "* feature" ]] || false
|
|
|
|
# verify we have the feature branch version of the table
|
|
run dolt sql -q "select * from feature;" -r csv
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "1,200" ]] || false
|
|
}
|
|
|
|
@test "checkout: checkout specific table from branch" {
|
|
# setup tables
|
|
dolt sql -q "create table users (id int primary key, name varchar(50));"
|
|
dolt sql -q "create table products (id int primary key, name varchar(50));"
|
|
dolt sql -q "insert into users values (1, 'Alice');"
|
|
dolt sql -q "insert into products values (1, 'Widget');"
|
|
dolt add .
|
|
dolt commit -m "Add initial tables"
|
|
|
|
# create a branch with different data
|
|
dolt checkout -b feature
|
|
dolt sql -q "update users set name = 'Bob' where id = 1;"
|
|
dolt sql -q "update products set name = 'Gadget' where id = 1;"
|
|
dolt add .
|
|
dolt commit -m "Update data on feature branch"
|
|
|
|
dolt checkout main
|
|
|
|
# checkout only the users table from feature branch
|
|
dolt checkout feature -- users
|
|
|
|
# verify we got the users table from feature branch
|
|
run dolt sql -q "select * from users;" -r csv
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "1,Bob" ]] || false
|
|
|
|
# verify products table is still from main
|
|
run dolt sql -q "select * from products;" -r csv
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "1,Widget" ]] || false
|
|
|
|
# verify we're still on main
|
|
run dolt branch
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "* main" ]] || false
|
|
}
|
|
|
|
@test "checkout: remote tracking branch shorthand" {
|
|
mkdir -p remote-repo
|
|
mkdir -p local-repo
|
|
cd local-repo
|
|
dolt init
|
|
dolt remote add origin file://../remote-repo
|
|
dolt push -u origin main
|
|
|
|
# setup initial commit
|
|
dolt sql -q "create table test (id int primary key, val int);"
|
|
dolt sql -q "insert into test values (1, 100);"
|
|
dolt add .
|
|
dolt commit -m "Initial commit"
|
|
|
|
# create a feature branch and push
|
|
dolt checkout -b feature
|
|
dolt sql -q "update test set val = 200 where id = 1;"
|
|
dolt add .
|
|
dolt commit -m "Update on feature branch"
|
|
dolt push origin feature
|
|
|
|
# verify the remote tracking branch exists
|
|
run dolt branch -a
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "remotes/origin/feature" ]] || false
|
|
|
|
# use DWIM to checkout and create a local branch from remote tracking branch
|
|
dolt checkout main
|
|
dolt branch -D feature # delete local feature branch if it exists
|
|
dolt checkout feature
|
|
|
|
# verify we're now on a local feature branch
|
|
run dolt branch
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "* feature" ]] || false
|
|
|
|
# verify the data from the feature branch
|
|
run dolt sql -q "select * from test;" -r csv
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "1,200" ]] || false
|
|
}
|
|
|
|
@test "checkout: error on ambiguous name matching tracking branch and table" {
|
|
mkdir -p remote-repo
|
|
mkdir -p local-repo
|
|
cd local-repo
|
|
dolt init
|
|
dolt remote add origin file://../remote-repo
|
|
dolt push -u origin main
|
|
|
|
# create a branch called 'feature' on the remote
|
|
dolt sql -q "create table test (id int primary key, val int);"
|
|
dolt sql -q "insert into test values (1, 50);"
|
|
dolt add .
|
|
dolt commit -m "Initial commit"
|
|
dolt push origin main
|
|
dolt checkout -b feature
|
|
dolt sql -q "update test set val = 200 where id = 1;"
|
|
dolt add .
|
|
dolt commit -m "Update on feature branch"
|
|
dolt push origin feature
|
|
|
|
# verify remote tracking branch exists
|
|
run dolt branch -a
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "remotes/origin/feature" ]] || false
|
|
|
|
# create a table with the same name as the tracking branch
|
|
dolt checkout main
|
|
dolt sql -q "create table feature (id int primary key, value int);"
|
|
dolt sql -q "insert into feature values (1, 100);"
|
|
dolt add .
|
|
dolt commit -m "Create table with same name as tracking branch"
|
|
|
|
# try to checkout "feature" without disambiguation
|
|
# this should fail because it could refer to either the table or the tracking branch
|
|
dolt branch -D feature # delete local branch since this only happens when it does not exist
|
|
run dolt checkout feature
|
|
[ "$status" -ne 0 ]
|
|
[[ "$output" =~ "could be both a local table and a tracking branch" ]] || false
|
|
[[ "$output" =~ "Please use -- to disambiguate" ]] || false
|
|
|
|
# verify we're still on main
|
|
run dolt branch
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "* main" ]] || false
|
|
|
|
# test that we can disambiguate with -- for the table
|
|
dolt checkout -- feature
|
|
|
|
# verify table was restored from HEAD
|
|
run dolt sql -q "select * from feature;" -r csv
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "1,100" ]] || false
|
|
|
|
# test that we can disambiguate for the branch using --
|
|
dolt checkout feature --
|
|
|
|
# verify we're now on a local feature branch
|
|
run dolt branch
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "* feature" ]] || false
|
|
}
|
|
|
|
@test "checkout: default to local branch checkout after disambiguation" {
|
|
mkdir -p remote-repo
|
|
mkdir -p local-repo
|
|
cd local-repo
|
|
dolt init
|
|
dolt remote add origin file://../remote-repo
|
|
dolt push -u origin main
|
|
|
|
# create a branch called 'feature' on the remote
|
|
dolt sql -q "create table test (id int primary key, val int);"
|
|
dolt sql -q "insert into test values (1, 50);"
|
|
dolt add .
|
|
dolt commit -m "Initial commit"
|
|
dolt push origin main
|
|
dolt checkout -b feature
|
|
dolt sql -q "update test set val = 200 where id = 1;"
|
|
dolt add .
|
|
dolt commit -m "Update on feature branch"
|
|
dolt push origin feature
|
|
|
|
# verify remote tracking branch exists
|
|
run dolt branch -a
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "remotes/origin/feature" ]] || false
|
|
|
|
# create a table with the same name as the tracking branch
|
|
dolt checkout main
|
|
dolt sql -q "create table feature (id int primary key, value int);"
|
|
dolt sql -q "insert into feature values (1, 100);"
|
|
dolt add .
|
|
dolt commit -m "Create table with same name as tracking branch"
|
|
|
|
# try to checkout "feature" without disambiguation
|
|
# this should fail because it could refer to either the table or the tracking branch
|
|
dolt branch -D feature # delete local branch since this only happens when it does not exist
|
|
|
|
# test that we can disambiguate for the branch using --
|
|
dolt checkout feature --
|
|
|
|
# verify we're now on a local feature branch
|
|
run dolt branch
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "* feature" ]] || false
|
|
|
|
run dolt checkout main
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "Switched to branch 'main'" ]] || false
|
|
|
|
run dolt checkout feature
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "Switched to branch 'feature'" ]] || false
|
|
}
|
|
|
|
@test "checkout: error with multiple refs using --" {
|
|
# setup branches and tables
|
|
dolt sql -q "create table feature (id int primary key, value int);"
|
|
dolt add .
|
|
dolt commit -m "Add feature table"
|
|
|
|
# create multiple branches
|
|
dolt branch branch1
|
|
dolt branch branch2
|
|
|
|
# attempt to checkout with multiple refs, which should fail
|
|
run dolt checkout branch1 branch2 -- feature
|
|
[ "$status" -ne 0 ]
|
|
[[ "$output" =~ "only one reference" ]] || false
|
|
|
|
# verify we're still on main branch
|
|
run dolt branch
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "* main" ]] || false
|
|
}
|
|
|
|
@test "checkout: checkout multiple tables using --" {
|
|
# setup multiple tables
|
|
dolt sql -q "create table table1 (id int primary key, value int);"
|
|
dolt sql -q "create table table2 (id int primary key, name varchar(50));"
|
|
dolt sql -q "insert into table1 values (1, 100);"
|
|
dolt sql -q "insert into table2 values (1, 'original');"
|
|
dolt add .
|
|
dolt commit -m "Add initial tables"
|
|
|
|
# create feature branch with modifications to both tables
|
|
dolt checkout -b feature
|
|
dolt sql -q "update table1 set value = 200 where id = 1;"
|
|
dolt sql -q "update table2 set name = 'modified' where id = 1;"
|
|
dolt add .
|
|
dolt commit -m "Update tables on feature branch"
|
|
|
|
# go back to main and make different changes
|
|
dolt checkout main
|
|
dolt sql -q "update table1 set value = 150 where id = 1;"
|
|
dolt sql -q "update table2 set name = 'changed' where id = 1;"
|
|
|
|
# checkout multiple tables from feature branch
|
|
dolt checkout feature -- table1 table2
|
|
|
|
# verify both tables were updated from feature branch
|
|
run dolt sql -q "select * from table1;" -r csv
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "1,200" ]] || false
|
|
|
|
run dolt sql -q "select * from table2;" -r csv
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "1,modified" ]] || false
|
|
|
|
# verify we're still on main branch
|
|
run dolt branch
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "* main" ]] || false
|
|
}
|
|
|
|
@test "checkout: more than one remote share same branch name" {
|
|
# setup two remotes with the same branch name
|
|
mkdir -p remote1
|
|
mkdir -p remote2
|
|
dolt remote add origin file://remote1
|
|
dolt remote add origin2 file://remote2
|
|
|
|
# create a branch on both remotes
|
|
dolt checkout -b feature
|
|
dolt sql -q "create table test (id int primary key, value int);"
|
|
dolt sql -q "insert into test values (1, 100);"
|
|
dolt add .
|
|
dolt commit -m "Add feature table"
|
|
dolt push origin feature
|
|
dolt push origin2 feature
|
|
|
|
# verify both remotes have the feature branch
|
|
run dolt branch -a
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "remotes/origin/feature" ]] || false
|
|
[[ "$output" =~ "remotes/origin2/feature" ]] || false
|
|
|
|
dolt checkout main
|
|
dolt branch -D feature # delete local feature branch to cause ambiguity
|
|
|
|
# try to checkout feature without disambiguation, should fail
|
|
run dolt checkout feature
|
|
[ "$status" -ne 0 ]
|
|
echo "$output"
|
|
[[ "$output" =~ "'feature' matched multiple (2) remote tracking branches" ]] || false
|
|
|
|
run dolt checkout --track origin/feature
|
|
[ "$status" -eq 0 ]
|
|
echo "$output"
|
|
[[ "$output" =~ "Switched to branch 'feature'" ]] || false
|
|
[[ "$output" =~ "branch 'feature' set up to track 'origin/feature'" ]] || false
|
|
|
|
# verify we're still on main branch
|
|
run dolt branch
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "* feature" ]] || false
|
|
}
|
|
|
|
@test "checkout: warning on missing table checkout" {
|
|
# create a table and commit it
|
|
dolt sql -q "create table test (id int primary key, value int);"
|
|
dolt sql -q "insert into test values (1, 100);"
|
|
dolt add .
|
|
dolt commit -m "Add test table"
|
|
|
|
# make modifications to existing table
|
|
dolt sql -q "update test set value = 200 where id = 1;"
|
|
|
|
# try to checkout a non-existent table, should fail
|
|
run dolt checkout missing_table
|
|
[ "$status" -ne 0 ]
|
|
[[ "$output" =~ "tablespec 'missing_table' did not match any table(s) known to dolt" ]] || false
|
|
|
|
# verify the existing table modifications are still present
|
|
run dolt sql -q "select * from test;" -r csv
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "1,200" ]] || false
|
|
|
|
# try to checkout multiple tables with one missing, should fail
|
|
run dolt checkout -- test missing_table
|
|
[ "$status" -ne 0 ]
|
|
[[ "$output" =~ "tablespec 'missing_table' did not match any table(s) known to dolt" ]] || false
|
|
|
|
# verify the existing table was checkout successfully
|
|
run dolt sql -q "select * from test;" -r csv
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "1,100" ]] || false
|
|
|
|
# try to checkout multiple missing tables, should fail with multiple errors
|
|
run dolt checkout -- missing1 missing2
|
|
[ "$status" -ne 0 ]
|
|
[[ "$output" =~ "tablespec 'missing1' did not match any table(s) known to dolt" ]] || false
|
|
[[ "$output" =~ "tablespec 'missing2' did not match any table(s) known to dolt" ]] || false
|
|
|
|
# verify we're still on main branch
|
|
run dolt branch
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "* main" ]] || false
|
|
}
|
|
|
|
@test "checkout: --no-overwrite-ignore aborts when ignored table would be overwritten" {
|
|
# Setup: create a table and an ignore pattern on main
|
|
dolt sql <<SQL
|
|
CREATE TABLE ignored_tbl (pk int PRIMARY KEY, val int);
|
|
INSERT INTO ignored_tbl VALUES (1, 100);
|
|
INSERT INTO dolt_ignore VALUES ('ignored_tbl', true);
|
|
SQL
|
|
dolt add -A --force
|
|
dolt commit -m "add ignored table and ignore pattern on main"
|
|
|
|
# Create a branch 'other' and modify the ignored table there
|
|
dolt checkout -b other
|
|
dolt sql -q "INSERT INTO ignored_tbl VALUES (2, 200)"
|
|
dolt add -A --force
|
|
dolt commit -m "modify ignored table on other branch" --force
|
|
|
|
# Go back to main
|
|
dolt checkout main
|
|
|
|
# Checkout with --no-overwrite-ignore should abort
|
|
run dolt checkout --no-overwrite-ignore other
|
|
[ "$status" -ne 0 ]
|
|
[[ "$output" =~ "ignored tables would be overwritten by checkout" ]] || false
|
|
[[ "$output" =~ "ignored_tbl" ]] || false
|
|
|
|
# Verify we're still on main
|
|
run dolt branch
|
|
[[ "$output" =~ "* main" ]] || false
|
|
}
|
|
|
|
@test "checkout: --overwrite-ignore allows checkout when ignored table would be overwritten" {
|
|
dolt sql <<SQL
|
|
CREATE TABLE ignored_tbl (pk int PRIMARY KEY, val int);
|
|
INSERT INTO ignored_tbl VALUES (1, 100);
|
|
INSERT INTO dolt_ignore VALUES ('ignored_tbl', true);
|
|
SQL
|
|
dolt add -A --force
|
|
dolt commit -m "add ignored table and ignore pattern on main"
|
|
|
|
dolt checkout -b other
|
|
dolt sql -q "INSERT INTO ignored_tbl VALUES (2, 200)"
|
|
dolt add -A --force
|
|
dolt commit -m "modify ignored table on other branch" --force
|
|
|
|
dolt checkout main
|
|
|
|
# Explicit --overwrite-ignore should succeed
|
|
run dolt checkout --overwrite-ignore other
|
|
[ "$status" -eq 0 ]
|
|
}
|
|
|
|
@test "checkout: default behavior overwrites ignored tables (no flag)" {
|
|
dolt sql <<SQL
|
|
CREATE TABLE ignored_tbl (pk int PRIMARY KEY, val int);
|
|
INSERT INTO ignored_tbl VALUES (1, 100);
|
|
INSERT INTO dolt_ignore VALUES ('ignored_tbl', true);
|
|
SQL
|
|
dolt add -A --force
|
|
dolt commit -m "add ignored table and ignore pattern on main"
|
|
|
|
dolt checkout -b other
|
|
dolt sql -q "INSERT INTO ignored_tbl VALUES (2, 200)"
|
|
dolt add -A --force
|
|
dolt commit -m "modify ignored table on other branch" --force
|
|
|
|
dolt checkout main
|
|
|
|
# Default behavior should overwrite (no error)
|
|
run dolt checkout other
|
|
[ "$status" -eq 0 ]
|
|
}
|
|
|
|
@test "checkout: --overwrite-ignore and --no-overwrite-ignore are mutually exclusive" {
|
|
dolt branch other
|
|
run dolt checkout --overwrite-ignore --no-overwrite-ignore other
|
|
[ "$status" -ne 0 ]
|
|
[[ "$output" =~ "mutually exclusive" ]] || false
|
|
}
|
|
|
|
@test "checkout: --no-overwrite-ignore allows checkout when ignored table is unchanged" {
|
|
# Setup: create ignored table on main
|
|
dolt sql <<SQL
|
|
CREATE TABLE ignored_tbl (pk int PRIMARY KEY, val int);
|
|
INSERT INTO ignored_tbl VALUES (1, 100);
|
|
INSERT INTO dolt_ignore VALUES ('ignored_tbl', true);
|
|
SQL
|
|
dolt add -A --force
|
|
dolt commit -m "add ignored table on main"
|
|
|
|
# Create branch 'other' WITHOUT modifying the ignored table
|
|
dolt checkout -b other
|
|
dolt sql -q "CREATE TABLE normal_tbl (pk int PRIMARY KEY)"
|
|
dolt add -A
|
|
dolt commit -m "add normal table on other branch"
|
|
|
|
dolt checkout main
|
|
|
|
# Since the ignored table is unchanged between branches, checkout should succeed
|
|
run dolt checkout --no-overwrite-ignore other
|
|
[ "$status" -eq 0 ]
|
|
}
|
|
|
|
@test "checkout: --no-overwrite-ignore does not warn when ignored table only exists on target branch" {
|
|
# Create an ignored table on a branch but not on main
|
|
dolt checkout -b other
|
|
dolt sql <<SQL
|
|
CREATE TABLE ignored_tbl (pk int PRIMARY KEY, val int);
|
|
INSERT INTO ignored_tbl VALUES (1, 100);
|
|
INSERT INTO dolt_ignore VALUES ('ignored_tbl', true);
|
|
SQL
|
|
dolt add -A --force
|
|
dolt commit -m "add ignored table on other branch" --force
|
|
|
|
dolt checkout main
|
|
|
|
# main has never seen ignored_tbl. Checking out 'other' should succeed
|
|
# because there is no local ignored table to overwrite.
|
|
run dolt checkout --no-overwrite-ignore other
|
|
[ "$status" -eq 0 ]
|
|
}
|
|
|
|
@test "checkout: --force combined with --no-overwrite-ignore still blocks ignored table overwrite" {
|
|
dolt sql <<SQL
|
|
CREATE TABLE ignored_tbl (pk int PRIMARY KEY, val int);
|
|
INSERT INTO ignored_tbl VALUES (1, 100);
|
|
INSERT INTO dolt_ignore VALUES ('ignored_tbl', true);
|
|
CREATE TABLE normal_tbl (pk int PRIMARY KEY, val int);
|
|
INSERT INTO normal_tbl VALUES (1, 1);
|
|
SQL
|
|
dolt add -A --force
|
|
dolt commit -m "add tables on main" --force
|
|
|
|
dolt checkout -b other
|
|
dolt sql -q "INSERT INTO ignored_tbl VALUES (2, 200)"
|
|
dolt sql -q "INSERT INTO normal_tbl VALUES (2, 2)"
|
|
dolt add -A --force
|
|
dolt commit -m "modify tables on other branch" --force
|
|
|
|
dolt checkout main
|
|
# Make a local working set change so --force is relevant
|
|
dolt sql -q "INSERT INTO normal_tbl VALUES (3, 3)"
|
|
|
|
# --force discards working set changes, but --no-overwrite-ignore
|
|
# should still block the checkout because the ignored table differs.
|
|
run dolt checkout --force --no-overwrite-ignore other
|
|
[ "$status" -ne 0 ]
|
|
[[ "$output" =~ "ignored tables would be overwritten by checkout" ]] || false
|
|
}
|
|
|
|
@test "checkout: --no-overwrite-ignore with multiple ignored tables only reports overwritten ones" {
|
|
dolt sql <<SQL
|
|
CREATE TABLE ign_changed (pk int PRIMARY KEY, val int);
|
|
INSERT INTO ign_changed VALUES (1, 100);
|
|
CREATE TABLE ign_same (pk int PRIMARY KEY, val int);
|
|
INSERT INTO ign_same VALUES (1, 100);
|
|
INSERT INTO dolt_ignore VALUES ('ign_%', true);
|
|
SQL
|
|
dolt add -A --force
|
|
dolt commit -m "add two ignored tables on main" --force
|
|
|
|
dolt checkout -b other
|
|
# Only modify one of the ignored tables
|
|
dolt sql -q "INSERT INTO ign_changed VALUES (2, 200)"
|
|
dolt add -A --force
|
|
dolt commit -m "modify one ignored table on other branch" --force
|
|
|
|
dolt checkout main
|
|
|
|
run dolt checkout --no-overwrite-ignore other
|
|
[ "$status" -ne 0 ]
|
|
[[ "$output" =~ "ign_changed" ]] || false
|
|
# ign_same should NOT appear in the error since it is unchanged
|
|
[[ ! "$output" =~ "ign_same" ]] || false
|
|
}
|
|
|
|
@test "checkout: -b with --no-overwrite-ignore does not block new branch from HEAD" {
|
|
dolt sql <<SQL
|
|
CREATE TABLE ignored_tbl (pk int PRIMARY KEY, val int);
|
|
INSERT INTO ignored_tbl VALUES (1, 100);
|
|
INSERT INTO dolt_ignore VALUES ('ignored_tbl', true);
|
|
SQL
|
|
dolt add -A --force
|
|
dolt commit -m "add ignored table on main" --force
|
|
|
|
# Creating a new branch from HEAD should never trigger the check
|
|
# because the new branch starts from the same commit.
|
|
run dolt checkout -b newbranch --no-overwrite-ignore
|
|
[ "$status" -eq 0 ]
|
|
|
|
# Verify we are on the new branch
|
|
run dolt branch
|
|
[[ "$output" =~ "* newbranch" ]] || false
|
|
}
|
|
|
|
@test "checkout: --no-overwrite-ignore does not warn when ignored table only exists locally" {
|
|
# Create a branch 'other' FIRST (before the ignored table exists)
|
|
dolt branch other
|
|
|
|
# Now add an ignored table on main
|
|
dolt sql <<SQL
|
|
CREATE TABLE ignored_tbl (pk int PRIMARY KEY, val int);
|
|
INSERT INTO ignored_tbl VALUES (1, 100);
|
|
INSERT INTO dolt_ignore VALUES ('ignored_tbl', true);
|
|
SQL
|
|
dolt add -A --force
|
|
dolt commit -m "add ignored table on main"
|
|
|
|
# 'other' has never seen ignored_tbl. Checking out should NOT warn
|
|
# because nothing on the target branch is overwriting the table.
|
|
run dolt checkout --no-overwrite-ignore other
|
|
[ "$status" -eq 0 ]
|
|
}
|
|
|
|
@test "checkout: dolt checkout HEAD <table> leaves ignored tables unstaged" {
|
|
# Commit the ignore rule first so it is in effect
|
|
dolt sql -q "INSERT INTO dolt_ignore VALUES ('private_data', true)"
|
|
dolt add dolt_ignore
|
|
dolt commit -m "add ignore rule for private_data"
|
|
|
|
dolt sql -q "CREATE TABLE mytable (pk int PRIMARY KEY, val int)"
|
|
dolt sql -q "INSERT INTO mytable VALUES (1, 10)"
|
|
dolt add mytable
|
|
dolt commit -m "add mytable"
|
|
|
|
# Create private_data only in the working tree, never committed
|
|
dolt sql -q "CREATE TABLE private_data (pk int PRIMARY KEY, secret varchar(100))"
|
|
dolt sql -q "INSERT INTO private_data VALUES (1, 'secret')"
|
|
|
|
# Modify mytable so checkout HEAD -- mytable has something to restore
|
|
dolt sql -q "INSERT INTO mytable VALUES (2, 20)"
|
|
|
|
run dolt checkout HEAD -- mytable
|
|
[ "$status" -eq 0 ]
|
|
|
|
# dolt_status is queried directly because dolt status hides ignored tables
|
|
# regardless of whether they are in the index, so the CLI output cannot detect index state.
|
|
run dolt sql -q "SELECT table_name FROM dolt_status WHERE table_name = 'private_data'" -r csv
|
|
[ "$status" -eq 0 ]
|
|
[[ ! "$output" =~ "private_data" ]] || false
|
|
}
|
|
|
|
@test "checkout: dolt checkout . preserves ignored tables" {
|
|
# Commit the ignore rule so it is in effect
|
|
dolt sql -q "INSERT INTO dolt_ignore VALUES ('ignored_tbl', true)"
|
|
dolt add dolt_ignore
|
|
dolt commit -m "add ignore rule"
|
|
|
|
# Create a normal table and commit it so there is a HEAD to restore to
|
|
dolt sql -q "CREATE TABLE normal_tbl (pk int PRIMARY KEY)"
|
|
dolt add normal_tbl
|
|
dolt commit -m "add normal table"
|
|
|
|
# Create the ignored table in the working tree. It is never committed.
|
|
dolt sql -q "CREATE TABLE ignored_tbl (pk int PRIMARY KEY, val int)"
|
|
dolt sql -q "INSERT INTO ignored_tbl VALUES (1, 100)"
|
|
|
|
# Make a working-tree change to the normal table so checkout . has work to do
|
|
dolt sql -q "INSERT INTO normal_tbl VALUES (99)"
|
|
|
|
run dolt checkout .
|
|
[ "$status" -eq 0 ]
|
|
|
|
run dolt sql -q "SELECT pk FROM normal_tbl" -r csv
|
|
[ "$status" -eq 0 ]
|
|
[[ ! "$output" =~ "99" ]] || false
|
|
|
|
run dolt sql -q "SELECT pk, val FROM ignored_tbl" -r csv
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "1,100" ]] || false
|
|
}
|
|
|
|
@test "checkout: dolt checkout . preserves untracked tables" {
|
|
dolt sql -q "CREATE TABLE normal_tbl (pk int PRIMARY KEY)"
|
|
dolt add normal_tbl
|
|
dolt commit -m "add normal_tbl"
|
|
|
|
# Create a table that has never been added to the index or committed
|
|
dolt sql -q "CREATE TABLE untracked_tbl (pk int PRIMARY KEY, val int)"
|
|
dolt sql -q "INSERT INTO untracked_tbl VALUES (1, 42)"
|
|
|
|
# Dirty normal_tbl so checkout . has something to restore
|
|
dolt sql -q "INSERT INTO normal_tbl VALUES (99)"
|
|
|
|
run dolt checkout .
|
|
[ "$status" -eq 0 ]
|
|
|
|
run dolt sql -q "SELECT pk FROM normal_tbl" -r csv
|
|
[ "$status" -eq 0 ]
|
|
[[ ! "$output" =~ "99" ]] || false
|
|
|
|
run dolt sql -q "SELECT pk, val FROM untracked_tbl" -r csv
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "1,42" ]] || false
|
|
}
|