wehub-resource-sync
694 lines
22 KiB
Bash
694 lines
22 KiB
Bash
#!/usr/bin/env bats
|
|
load $BATS_TEST_DIRNAME/helper/common.bash
|
|
load $BATS_TEST_DIRNAME/helper/query-server-common.bash
|
|
|
|
# Tests for SSH transfer operations (clone, pull, push via SSH URLs)
|
|
# Uses mock SSH to avoid requiring an SSH server
|
|
|
|
setup() {
|
|
cd "$BATS_TEST_TMPDIR"
|
|
|
|
# Create mock SSH script that executes the remote command locally.
|
|
# Real SSH runs its last argument as a command on the remote host.
|
|
# buildTransferCommand always passes the dolt transfer invocation as
|
|
# the final argument, so we just exec that. All args are logged so
|
|
# tests can verify user@host, -p port, etc.
|
|
cat > "$BATS_TEST_TMPDIR/mock_ssh" <<'EOF'
|
|
#!/bin/bash
|
|
echo "$@" >> "$BATS_TEST_TMPDIR/mock_ssh.log"
|
|
COMMAND="${@: -1}"
|
|
exec $COMMAND 2> >(tee -a "$BATS_TEST_TMPDIR/transfer_stderr.log" >&2)
|
|
EOF
|
|
chmod +x "$BATS_TEST_TMPDIR/mock_ssh"
|
|
|
|
export DOLT_SSH_COMMAND="$BATS_TEST_TMPDIR/mock_ssh"
|
|
}
|
|
|
|
teardown() {
|
|
unset DOLT_SSH_COMMAND
|
|
stop_sql_server
|
|
}
|
|
|
|
@test "ssh-transfer: transfer command works with --data-dir" {
|
|
mkdir "repo1"
|
|
cd "repo1"
|
|
dolt init
|
|
dolt sql -q "CREATE TABLE test (id INT PRIMARY KEY, val TEXT);"
|
|
dolt sql -q "INSERT INTO test VALUES (1, 'hello');"
|
|
dolt add .
|
|
dolt commit -m "initial commit"
|
|
|
|
cd ..
|
|
run dolt --data-dir="repo1" transfer </dev/null
|
|
# transfer command is kind of strange in that it always exits with status 0. It will even show an odd error
|
|
# here. That's all fine. We don't expect people to run this directly. We'll look at messages more closely from
|
|
# dolt clone, dolt push, dolt pull.
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "server error: EOF" ]] || false
|
|
}
|
|
|
|
@test "ssh-transfer: clone via SSH URL" {
|
|
mkdir "repo_source"
|
|
cd "repo_source"
|
|
dolt init
|
|
dolt sql -q "CREATE TABLE products (id VARCHAR(36) DEFAULT (UUID()) PRIMARY KEY, name TEXT, price DECIMAL(10,2));"
|
|
dolt sql -q "INSERT INTO products (name, price) VALUES ('Widget', 19.99), ('Gadget', 29.99);"
|
|
dolt add .
|
|
dolt commit -m "initial data"
|
|
|
|
cd ..
|
|
run dolt clone "ssh://localhost$BATS_TEST_TMPDIR/repo_source" repo_clone
|
|
[ "$status" -eq 0 ]
|
|
[ -d repo_clone ]
|
|
|
|
cd repo_clone
|
|
run dolt sql -q "SELECT COUNT(*) FROM products;" -r csv
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "2" ]] || false
|
|
}
|
|
|
|
@test "ssh-transfer: clone with .dolt suffix in URL path" {
|
|
mkdir "repo_dotsuffix"
|
|
cd "repo_dotsuffix"
|
|
dolt init
|
|
dolt sql -q "CREATE TABLE test (id INT PRIMARY KEY);"
|
|
dolt sql -q "INSERT INTO test VALUES (1), (2), (3);"
|
|
dolt add .
|
|
dolt commit -m "test data"
|
|
|
|
cd ..
|
|
run dolt clone "ssh://localhost$BATS_TEST_TMPDIR/repo_dotsuffix/.dolt" repo_dotsuffix_clone
|
|
[ "$status" -eq 0 ]
|
|
[ -d repo_dotsuffix_clone ]
|
|
|
|
cd repo_dotsuffix_clone
|
|
run dolt sql -q "SELECT COUNT(*) FROM test;" -r csv
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "3" ]] || false
|
|
cd "$BATS_TEST_TMPDIR"
|
|
rm -rf repo_dotsuffix_clone
|
|
|
|
# repeat with /.dolt/ (trailing slash).
|
|
run dolt clone "ssh://localhost$BATS_TEST_TMPDIR/repo_dotsuffix/.dolt/" repo_dotsuffix_clone
|
|
[ "$status" -eq 0 ]
|
|
[ -d repo_dotsuffix_clone ]
|
|
|
|
cd repo_dotsuffix_clone
|
|
run dolt sql -q "SELECT COUNT(*) FROM test;" -r csv
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "3" ]] || false
|
|
}
|
|
|
|
@test "ssh-transfer: clone with user@host format" {
|
|
mkdir "repo_usertest"
|
|
cd "repo_usertest"
|
|
dolt init
|
|
dolt sql -q "CREATE TABLE test (id INT PRIMARY KEY);"
|
|
dolt sql -q "INSERT INTO test VALUES (1), (2), (3);"
|
|
dolt add .
|
|
dolt commit -m "test data"
|
|
|
|
cd ..
|
|
run dolt clone "ssh://testuser@localhost$BATS_TEST_TMPDIR/repo_usertest" repo_clone_user
|
|
[ "$status" -eq 0 ]
|
|
[ -d repo_clone_user ]
|
|
|
|
# Verify mock SSH received testuser@localhost
|
|
grep -q "testuser@localhost" "$BATS_TEST_TMPDIR/mock_ssh.log"
|
|
|
|
cd repo_clone_user
|
|
run dolt sql -q "SELECT COUNT(*) FROM test;" -r csv
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "3" ]] || false
|
|
}
|
|
|
|
@test "ssh-transfer: clone with custom port in URL" {
|
|
mkdir "repo_porttest"
|
|
cd "repo_porttest"
|
|
dolt init
|
|
dolt sql -q "CREATE TABLE test (id INT PRIMARY KEY);"
|
|
dolt sql -q "INSERT INTO test VALUES (1), (2), (3);"
|
|
dolt add .
|
|
dolt commit -m "test data"
|
|
|
|
cd ..
|
|
run dolt clone "ssh://localhost:9999$BATS_TEST_TMPDIR/repo_porttest" repo_port_clone
|
|
[ "$status" -eq 0 ]
|
|
[ -d repo_port_clone ]
|
|
|
|
# Verify -p 9999 was passed to mock SSH
|
|
grep -q "\-p 9999" "$BATS_TEST_TMPDIR/mock_ssh.log"
|
|
|
|
cd repo_port_clone
|
|
run dolt sql -q "SELECT COUNT(*) FROM test;" -r csv
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "3" ]] || false
|
|
}
|
|
|
|
@test "ssh-transfer: clone of GCed repo" {
|
|
mkdir "repo_gc"
|
|
cd "repo_gc"
|
|
dolt init
|
|
dolt sql -q "CREATE TABLE test (id INT PRIMARY KEY);"
|
|
dolt sql -q "INSERT INTO test VALUES (1), (2), (3);"
|
|
dolt add .
|
|
dolt commit -m "test data"
|
|
dolt gc
|
|
|
|
cd ..
|
|
run dolt clone "ssh://localhost$BATS_TEST_TMPDIR/repo_gc" repo_gc_clone
|
|
[ "$status" -eq 0 ]
|
|
[ -d repo_gc_clone ]
|
|
|
|
cd repo_gc_clone
|
|
run dolt sql -q "SELECT COUNT(*) FROM test;" -r csv
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "3" ]] || false
|
|
}
|
|
|
|
@test "ssh-transfer: pull changes from remote" {
|
|
mkdir "repo_pull_source"
|
|
cd "repo_pull_source"
|
|
dolt init
|
|
dolt sql -q "CREATE TABLE items (id INT PRIMARY KEY, name TEXT);"
|
|
dolt sql -q "INSERT INTO items VALUES (1, 'item1');"
|
|
dolt add .
|
|
dolt commit -m "initial"
|
|
|
|
cd ..
|
|
run dolt clone "ssh://localhost$BATS_TEST_TMPDIR/repo_pull_source" repo_pull_clone
|
|
[ "$status" -eq 0 ]
|
|
|
|
cd "repo_pull_source"
|
|
dolt sql -q "INSERT INTO items VALUES (2, 'item2');"
|
|
dolt add .
|
|
dolt commit -m "add item2"
|
|
|
|
cd "../repo_pull_clone"
|
|
run dolt pull origin
|
|
[ "$status" -eq 0 ]
|
|
|
|
run dolt sql -q "SELECT COUNT(*) FROM items;" -r csv
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "2" ]] || false
|
|
}
|
|
|
|
@test "ssh-transfer: push changes to remote" {
|
|
mkdir "repo_push_source"
|
|
cd "repo_push_source"
|
|
dolt init
|
|
dolt sql -q "CREATE TABLE data (id INT PRIMARY KEY, val TEXT);"
|
|
dolt sql -q "INSERT INTO data VALUES (1, 'original');"
|
|
dolt add .
|
|
dolt commit -m "initial"
|
|
|
|
cd ..
|
|
run dolt clone "ssh://localhost$BATS_TEST_TMPDIR/repo_push_source" repo_push_clone
|
|
[ "$status" -eq 0 ]
|
|
|
|
cd "repo_push_clone"
|
|
dolt sql -q "INSERT INTO data VALUES (2, 'from_clone');"
|
|
dolt add .
|
|
dolt commit -m "add from clone"
|
|
|
|
# Record the commit we expect to push
|
|
PUSH_COMMIT=$(dolt log --oneline -n 1 | awk '{print $1}')
|
|
|
|
run dolt push origin main
|
|
[ "$status" -eq 0 ]
|
|
|
|
# After a successful push, the local tracking ref origin/main should
|
|
# match the commit we just pushed.
|
|
run dolt log --oneline -n 1 origin/main
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "$PUSH_COMMIT" ]] || false
|
|
}
|
|
|
|
@test "ssh-transfer: handle branch operations" {
|
|
mkdir "repo_branch_source"
|
|
cd "repo_branch_source"
|
|
dolt init
|
|
dolt sql -q "CREATE TABLE main_table (id INT PRIMARY KEY);"
|
|
dolt sql -q "INSERT INTO main_table VALUES (1);"
|
|
dolt add .
|
|
dolt commit -m "main commit"
|
|
|
|
dolt checkout -b feature
|
|
dolt sql -q "CREATE TABLE feature_table (id INT PRIMARY KEY);"
|
|
dolt sql -q "INSERT INTO feature_table VALUES (1);"
|
|
dolt add .
|
|
dolt commit -m "feature commit"
|
|
dolt checkout main
|
|
|
|
cd ..
|
|
run dolt clone "ssh://localhost$BATS_TEST_TMPDIR/repo_branch_source" repo_branch_clone
|
|
[ "$status" -eq 0 ]
|
|
|
|
cd "repo_branch_clone"
|
|
run dolt fetch origin feature
|
|
[ "$status" -eq 0 ]
|
|
|
|
run dolt checkout feature
|
|
[ "$status" -eq 0 ]
|
|
|
|
run dolt sql -q "SHOW TABLES;" -r csv
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "feature_table" ]] || false
|
|
}
|
|
|
|
@test "ssh-transfer: concurrent clone operations" {
|
|
mkdir "repo_concurrent_source"
|
|
cd "repo_concurrent_source"
|
|
dolt init
|
|
dolt sql -q "CREATE TABLE test (id INT PRIMARY KEY);"
|
|
dolt sql -q "INSERT INTO test VALUES (1), (2), (3), (4), (5);"
|
|
dolt add .
|
|
dolt commit -m "test data"
|
|
|
|
# Start multiple clones concurrently
|
|
cd ..
|
|
dolt clone "ssh://localhost$BATS_TEST_TMPDIR/repo_concurrent_source" repo_concurrent_1 &
|
|
PID1=$!
|
|
dolt clone "ssh://localhost$BATS_TEST_TMPDIR/repo_concurrent_source" repo_concurrent_2 &
|
|
PID2=$!
|
|
dolt clone "ssh://localhost$BATS_TEST_TMPDIR/repo_concurrent_source" repo_concurrent_3 &
|
|
PID3=$!
|
|
|
|
# Wait for all to complete
|
|
wait $PID1
|
|
STATUS1=$?
|
|
wait $PID2
|
|
STATUS2=$?
|
|
wait $PID3
|
|
STATUS3=$?
|
|
|
|
[ "$STATUS1" -eq 0 ]
|
|
[ "$STATUS2" -eq 0 ]
|
|
[ "$STATUS3" -eq 0 ]
|
|
|
|
# Verify all have correct data
|
|
for dir in repo_concurrent_1 repo_concurrent_2 repo_concurrent_3; do
|
|
cd "$dir"
|
|
run dolt sql -q "SELECT COUNT(*) FROM test;" -r csv
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "5" ]] || false
|
|
cd ..
|
|
done
|
|
}
|
|
|
|
@test "ssh-transfer: error handling for non-existent repository" {
|
|
run dolt clone "ssh://localhost/nonexistent/repo" should_fail
|
|
[ "$status" -ne 0 ]
|
|
[[ "$output" =~ "repository not found" ]] || false
|
|
}
|
|
|
|
@test "ssh-transfer: verify DOLT_SSH_COMMAND environment variable works" {
|
|
# All tests use DOLT_SSH_COMMAND, so this is kind of a sanity check to ensure that your can change it.
|
|
cat > "$BATS_TEST_TMPDIR/custom_ssh" <<'EOF'
|
|
#!/bin/bash
|
|
echo "CUSTOM_SSH $@" >> "$BATS_TEST_TMPDIR/custom_ssh.log"
|
|
COMMAND="${@: -1}"
|
|
exec $COMMAND 2>/dev/null
|
|
EOF
|
|
chmod +x "$BATS_TEST_TMPDIR/custom_ssh"
|
|
export DOLT_SSH_COMMAND="$BATS_TEST_TMPDIR/custom_ssh"
|
|
|
|
mkdir "repo_env_test"
|
|
cd "repo_env_test"
|
|
dolt init
|
|
dolt sql -q "CREATE TABLE test (id INT PRIMARY KEY);"
|
|
dolt add .
|
|
dolt commit -m "test"
|
|
|
|
cd ..
|
|
run dolt clone "ssh://localhost$BATS_TEST_TMPDIR/repo_env_test" repo_env_clone
|
|
[ "$status" -eq 0 ]
|
|
|
|
# Verify the custom SSH was used
|
|
[ -f "$BATS_TEST_TMPDIR/custom_ssh.log" ]
|
|
grep -q "CUSTOM_SSH.*localhost" "$BATS_TEST_TMPDIR/custom_ssh.log"
|
|
}
|
|
|
|
@test "ssh-transfer: DOLT_SSH_EXEC_PATH overrides remote dolt path" {
|
|
mkdir "repo_exec_path"
|
|
cd "repo_exec_path"
|
|
dolt init
|
|
dolt sql -q "CREATE TABLE test (id INT PRIMARY KEY);"
|
|
dolt sql -q "INSERT INTO test VALUES (1), (2);"
|
|
dolt add .
|
|
dolt commit -m "test"
|
|
|
|
# Create a mock SSH that logs the remote command and rewrites the
|
|
# custom dolt path back to the real binary so it can actually execute.
|
|
export REAL_DOLT_BIN="$(command -v dolt)"
|
|
[ -n "$REAL_DOLT_BIN" ]
|
|
|
|
cat > "$BATS_TEST_TMPDIR/mock_ssh_exec" <<'MOCK'
|
|
#!/bin/bash
|
|
COMMAND="${@: -1}"
|
|
echo "$COMMAND" >> "$BATS_TEST_TMPDIR/exec_path.log"
|
|
COMMAND=$(echo "$COMMAND" | sed "s|/nonsense/path/to/dolt|$REAL_DOLT_BIN|")
|
|
exec $COMMAND
|
|
MOCK
|
|
chmod +x "$BATS_TEST_TMPDIR/mock_ssh_exec"
|
|
|
|
export DOLT_SSH_COMMAND="$BATS_TEST_TMPDIR/mock_ssh_exec"
|
|
export DOLT_SSH_EXEC_PATH="/nonsense/path/to/dolt"
|
|
|
|
cd ..
|
|
run dolt clone "ssh://localhost$BATS_TEST_TMPDIR/repo_exec_path" repo_exec_clone
|
|
[ "$status" -eq 0 ]
|
|
|
|
# Verify the custom exec path was used in the remote command
|
|
[ -f "$BATS_TEST_TMPDIR/exec_path.log" ]
|
|
grep -q "/nonsense/path/to/dolt --data-dir" "$BATS_TEST_TMPDIR/exec_path.log"
|
|
}
|
|
|
|
@test "ssh-transfer: clone succeeds while sql-server is running" {
|
|
mkdir "repo_locked_read"
|
|
cd "repo_locked_read"
|
|
dolt init
|
|
dolt sql -q "CREATE TABLE test (id INT PRIMARY KEY, val TEXT);"
|
|
dolt sql -q "INSERT INTO test VALUES (1, 'one'), (2, 'two'), (3, 'three');"
|
|
dolt add .
|
|
dolt commit -m "initial data"
|
|
|
|
start_sql_server "repo_locked_read"
|
|
|
|
cd "$BATS_TEST_TMPDIR"
|
|
run dolt clone "ssh://localhost$BATS_TEST_TMPDIR/repo_locked_read" repo_locked_read_clone
|
|
[ "$status" -eq 0 ]
|
|
|
|
cd "repo_locked_read_clone"
|
|
run dolt sql -r csv -q "SELECT * FROM test;"
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "1,one" ]] || false
|
|
[[ "$output" =~ "2,two" ]] || false
|
|
[[ "$output" =~ "3,three" ]] || false
|
|
}
|
|
|
|
@test "ssh-transfer: push fails while sql-server is running" {
|
|
mkdir "repo_locked_push"
|
|
cd "repo_locked_push"
|
|
dolt init
|
|
dolt sql -q "CREATE TABLE test (id INT PRIMARY KEY, val TEXT);"
|
|
dolt sql -q "INSERT INTO test VALUES (1, 'original');"
|
|
dolt add .
|
|
dolt commit -m "initial"
|
|
|
|
cd "$BATS_TEST_TMPDIR"
|
|
run dolt clone "ssh://localhost$BATS_TEST_TMPDIR/repo_locked_push" repo_locked_push_clone
|
|
[ "$status" -eq 0 ]
|
|
|
|
# Start sql-server on the source repo to hold the manifest lock
|
|
cd "repo_locked_push"
|
|
start_sql_server "repo_locked_push"
|
|
|
|
# Make a change in the clone and try to push
|
|
cd "$BATS_TEST_TMPDIR/repo_locked_push_clone"
|
|
dolt sql -q "INSERT INTO test VALUES (2, 'from_clone');"
|
|
dolt add .
|
|
dolt commit -m "add from clone"
|
|
|
|
run dolt push origin main
|
|
# Push must fail when sql-server holds the lock.
|
|
[ "$status" -ne 0 ]
|
|
# The transfer command logs the real error to stderr; verify it.
|
|
grep -q "database is read only" "$BATS_TEST_TMPDIR/transfer_stderr.log"
|
|
}
|
|
|
|
@test "ssh-transfer: sql dolt_clone() via SSH URL" {
|
|
mkdir "repo_sql_clone_src"
|
|
cd "repo_sql_clone_src"
|
|
dolt init
|
|
dolt sql -q "CREATE TABLE test (id INT PRIMARY KEY, val TEXT);"
|
|
dolt sql -q "INSERT INTO test VALUES (1, 'a'), (2, 'b'), (3, 'c');"
|
|
dolt add .
|
|
dolt commit -m "initial"
|
|
|
|
# Start sql-server in a fresh directory (no pre-existing databases)
|
|
cd "$BATS_TEST_TMPDIR"
|
|
mkdir "sql_clone_server"
|
|
cd "sql_clone_server"
|
|
start_sql_server
|
|
|
|
dolt sql -q "CALL dolt_clone('ssh://localhost$BATS_TEST_TMPDIR/repo_sql_clone_src', 'sql_cloned');"
|
|
|
|
# Verify cloned data
|
|
run dolt --use-db sql_cloned sql -r csv -q "SELECT COUNT(*) FROM test;"
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "3" ]] || false
|
|
}
|
|
|
|
@test "ssh-transfer: sql dolt_push() to SSH remote" {
|
|
mkdir "repo_sql_push_src"
|
|
cd "repo_sql_push_src"
|
|
dolt init
|
|
dolt sql -q "CREATE TABLE test (id INT PRIMARY KEY);"
|
|
dolt sql -q "INSERT INTO test VALUES (1);"
|
|
dolt add .
|
|
dolt commit -m "initial"
|
|
|
|
cd "$BATS_TEST_TMPDIR"
|
|
dolt clone "ssh://localhost$BATS_TEST_TMPDIR/repo_sql_push_src" repo_sql_push_clone
|
|
|
|
cd "repo_sql_push_clone"
|
|
start_sql_server repo_sql_push_clone
|
|
|
|
dolt sql -q "INSERT INTO test VALUES (10);"
|
|
dolt sql -q "CALL dolt_commit('-a','-m', 'sql push 123');"
|
|
dolt sql -q "CALL dolt_push('origin', 'main');"
|
|
stop_sql_server 1
|
|
|
|
cd "$BATS_TEST_TMPDIR/repo_sql_push_src"
|
|
run dolt log --oneline -n 1
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "sql push 123" ]] || false
|
|
}
|
|
|
|
@test "ssh-transfer: sql dolt_pull() from SSH remote" {
|
|
mkdir "repo_sql_pull_src"
|
|
cd "repo_sql_pull_src"
|
|
dolt init
|
|
dolt sql -q "CREATE TABLE items (id INT PRIMARY KEY, name TEXT);"
|
|
dolt sql -q "INSERT INTO items VALUES (1, 'original');"
|
|
dolt add .
|
|
dolt commit -m "initial"
|
|
|
|
cd "$BATS_TEST_TMPDIR"
|
|
dolt clone "ssh://localhost$BATS_TEST_TMPDIR/repo_sql_pull_src" repo_sql_pull_clone
|
|
|
|
# Add new data to source
|
|
cd "repo_sql_pull_src"
|
|
dolt sql -q "INSERT INTO items VALUES (99, 'new_item');"
|
|
dolt add .
|
|
dolt commit -m "add new item"
|
|
|
|
cd "$BATS_TEST_TMPDIR/repo_sql_pull_clone"
|
|
start_sql_server repo_sql_pull_clone
|
|
dolt sql -q "CALL dolt_pull('origin');"
|
|
|
|
run dolt sql -r csv -q "SELECT * FROM items WHERE id=99;"
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "new_item" ]] || false
|
|
}
|
|
|
|
@test "ssh-transfer: sql dolt_remote(add) with SSH URL then push" {
|
|
mkdir "repo_sql_remote_src"
|
|
cd "repo_sql_remote_src"
|
|
dolt init
|
|
dolt sql -q "CREATE TABLE data (id INT PRIMARY KEY);"
|
|
dolt sql -q "INSERT INTO data VALUES (1), (2), (3);"
|
|
dolt add .
|
|
dolt commit -m "initial data"
|
|
|
|
cd "$BATS_TEST_TMPDIR"
|
|
dolt clone "ssh://localhost$BATS_TEST_TMPDIR/repo_sql_remote_src" repo_sql_remote_target
|
|
|
|
# Create a second clone as the local working copy
|
|
dolt clone "ssh://localhost$BATS_TEST_TMPDIR/repo_sql_remote_src" repo_sql_remote_local
|
|
cd "repo_sql_remote_local"
|
|
|
|
start_sql_server repo_sql_remote_local
|
|
dolt sql -q "CALL dolt_remote('add', 'target', 'ssh://localhost$BATS_TEST_TMPDIR/repo_sql_remote_target');"
|
|
dolt sql -q "INSERT INTO data VALUES (10);"
|
|
dolt sql -q "CALL dolt_commit('-a', '-m', 'push to target');"
|
|
dolt sql -q "CALL dolt_push('target', 'main');"
|
|
|
|
cd "$BATS_TEST_TMPDIR/repo_sql_remote_target"
|
|
run dolt log --oneline -n 1
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "push to target" ]] || false
|
|
}
|
|
|
|
@test "ssh-transfer: sql dolt_clone() fails for non-existent SSH repo" {
|
|
mkdir "sql_err_server"
|
|
cd "sql_err_server"
|
|
start_sql_server
|
|
|
|
# Attempt clone of non-existent path
|
|
run dolt sql -q "CALL dolt_clone('ssh://localhost/nonexistent/repo_does_not_exist');"
|
|
[ "$status" -ne 0 ]
|
|
[[ "$output" =~ "repository not found" ]] || false
|
|
}
|
|
|
|
@test "ssh-transfer: sql dolt_push() fails while sql-server locks target" {
|
|
mkdir "repo_sql_lockpush_src"
|
|
cd "repo_sql_lockpush_src"
|
|
dolt init
|
|
dolt sql -q "CREATE TABLE test (id INT PRIMARY KEY);"
|
|
dolt sql -q "INSERT INTO test VALUES (1);"
|
|
dolt add .
|
|
dolt commit -m "initial"
|
|
|
|
cd "$BATS_TEST_TMPDIR"
|
|
dolt clone "ssh://localhost$BATS_TEST_TMPDIR/repo_sql_lockpush_src" repo_sql_lockpush_clone
|
|
|
|
# Lock source with sql-server
|
|
cd "repo_sql_lockpush_src"
|
|
start_sql_server repo_sql_lockpush_src
|
|
|
|
cd "$BATS_TEST_TMPDIR/repo_sql_lockpush_clone"
|
|
dolt sql -q "INSERT INTO test VALUES (99);"
|
|
dolt sql -q "CALL dolt_commit('-a', '-m', 'should fail');"
|
|
run dolt sql -q "CALL dolt_push('origin', 'main');"
|
|
[ "$status" -ne 0 ]
|
|
[[ "$output" =~ "database is read only" ]] || false
|
|
}
|
|
@test "ssh-transfer: clone from bare backup repository" {
|
|
mkdir "repo_bare_src"
|
|
cd "repo_bare_src"
|
|
dolt init
|
|
dolt sql -q "CREATE TABLE items (id INT PRIMARY KEY, name TEXT);"
|
|
dolt sql -q "INSERT INTO items VALUES (1, 'alpha'), (2, 'beta');"
|
|
dolt add .
|
|
dolt commit -m "initial bare test"
|
|
|
|
dolt backup add bac1 "file://$BATS_TEST_TMPDIR/bare_backup"
|
|
dolt backup sync bac1
|
|
|
|
cd "$BATS_TEST_TMPDIR"
|
|
run dolt clone "ssh://localhost$BATS_TEST_TMPDIR/bare_backup" bare_clone
|
|
[ "$status" -eq 0 ]
|
|
|
|
cd "bare_clone"
|
|
run dolt sql -r csv -q "SELECT COUNT(*) FROM items;"
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "2" ]] || false
|
|
|
|
run dolt sql -r csv -q "SELECT name FROM items ORDER BY id;"
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "alpha" ]] || false
|
|
[[ "$output" =~ "beta" ]] || false
|
|
}
|
|
|
|
@test "ssh-transfer: pull from bare backup repository" {
|
|
mkdir "repo_bare_pull_src"
|
|
cd "repo_bare_pull_src"
|
|
dolt init
|
|
dolt sql -q "CREATE TABLE t (id INT PRIMARY KEY, v TEXT);"
|
|
dolt sql -q "INSERT INTO t VALUES (1, 'first');"
|
|
dolt add .
|
|
dolt commit -m "initial"
|
|
|
|
dolt backup add bac1 "file://$BATS_TEST_TMPDIR/bare_pull_backup"
|
|
dolt backup sync bac1
|
|
|
|
cd "$BATS_TEST_TMPDIR"
|
|
|
|
dolt clone "ssh://localhost$BATS_TEST_TMPDIR/bare_pull_backup" bare_pull_clone
|
|
|
|
# Add more data to source and re-sync to the backup.
|
|
cd "repo_bare_pull_src"
|
|
dolt sql -q "INSERT INTO t VALUES (2, 'second');"
|
|
dolt add .
|
|
dolt commit -m "add second row"
|
|
dolt backup sync bac1
|
|
|
|
cd "$BATS_TEST_TMPDIR/bare_pull_clone"
|
|
run dolt pull origin
|
|
[ "$status" -eq 0 ]
|
|
|
|
run dolt sql -r csv -q "SELECT COUNT(*) FROM t;"
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "2" ]] || false
|
|
}
|
|
|
|
@test "ssh-transfer: push to bare backup repository" {
|
|
mkdir "repo_bare_push_src"
|
|
cd "repo_bare_push_src"
|
|
dolt init
|
|
dolt sql -q "CREATE TABLE widgets (id INT PRIMARY KEY, color TEXT);"
|
|
dolt sql -q "INSERT INTO widgets VALUES (1, 'red');"
|
|
dolt add .
|
|
dolt commit -m "initial"
|
|
|
|
dolt backup add bac1 "file://$BATS_TEST_TMPDIR/bare_push_backup"
|
|
dolt backup sync bac1
|
|
|
|
cd "$BATS_TEST_TMPDIR"
|
|
|
|
dolt clone "ssh://localhost$BATS_TEST_TMPDIR/bare_push_backup" bare_push_clone
|
|
cd "bare_push_clone"
|
|
dolt sql -q "INSERT INTO widgets VALUES (2, 'blue');"
|
|
dolt add .
|
|
dolt commit -m "add blue widget"
|
|
|
|
PUSHED_COMMIT=$(dolt log --oneline -n 1 | awk '{print $1}')
|
|
run dolt push origin main
|
|
[ "$status" -eq 0 ]
|
|
|
|
cd "$BATS_TEST_TMPDIR"
|
|
dolt clone "ssh://localhost$BATS_TEST_TMPDIR/bare_push_backup" bare_push_verify
|
|
cd "bare_push_verify"
|
|
|
|
run dolt sql -r csv -q "SELECT COUNT(*) FROM widgets;"
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "2" ]] || false
|
|
|
|
run dolt log --oneline -n 1
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "$PUSHED_COMMIT" ]] || false
|
|
}
|
|
|
|
@test "ssh-transfer: push to empty directory creates bare repository" {
|
|
mkdir "repo_push_to_empty_src"
|
|
cd "repo_push_to_empty_src"
|
|
dolt init
|
|
dolt sql -q "CREATE TABLE t (id INT PRIMARY KEY, v TEXT);"
|
|
dolt sql -q "INSERT INTO t VALUES (1, 'hello');"
|
|
dolt add .
|
|
dolt commit -m "initial"
|
|
|
|
# Create an empty target directory and push to it via SSH.
|
|
mkdir "$BATS_TEST_TMPDIR/empty_bare_target"
|
|
dolt remote add bare "ssh://localhost$BATS_TEST_TMPDIR/empty_bare_target"
|
|
run dolt push bare main
|
|
[ "$status" -eq 0 ]
|
|
|
|
# The target should now be a bare repository: NBS files directly in the
|
|
# directory with no .dolt/ subdirectory.
|
|
[ -f "$BATS_TEST_TMPDIR/empty_bare_target/manifest" ] || false
|
|
[ ! -d "$BATS_TEST_TMPDIR/empty_bare_target/.dolt" ] || false
|
|
|
|
# Clone from the bare target to verify the data is intact.
|
|
cd "$BATS_TEST_TMPDIR"
|
|
run dolt clone "ssh://localhost$BATS_TEST_TMPDIR/empty_bare_target" bare_from_push
|
|
[ "$status" -eq 0 ]
|
|
|
|
cd "bare_from_push"
|
|
run dolt sql -r csv -q "SELECT v FROM t WHERE id=1;"
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "hello" ]] || false
|
|
|
|
# Restore from the bare repository using dolt backup restore.
|
|
cd "$BATS_TEST_TMPDIR"
|
|
run dolt backup restore "file://$BATS_TEST_TMPDIR/empty_bare_target" bare_restored
|
|
[ "$status" -eq 0 ]
|
|
|
|
cd "bare_restored"
|
|
run dolt sql -r csv -q "SELECT v FROM t WHERE id=1;"
|
|
[ "$status" -eq 0 ]
|
|
[[ "$output" =~ "hello" ]] || false
|
|
}
|