Skip to content

SeaweedFS is a distributed storage system for object storage (S3), file systems, Iceberg table buckets, and Lance vector buckets, designed to handle billions of files with O(1) disk access and effortless horizontal scaling.

8.6 KB
Raw Blame
#!/usr/bin/env bash
#
# Integration test: git clone & pull on a SeaweedFS FUSE mount.
#
# Verifies that the mount correctly supports git's file operations by:
#   1. Creating a bare repo on the mount (acts as a remote)
#   2. Cloning it, making commits, and pushing back to the mount
#   3. Cloning from the mount into a working directory also on the mount
#   4. Pushing additional commits to the bare repo
#   5. Checking out an older revision in the on-mount clone
#   6. Running git pull to fast-forward with real changes
#   7. Verifying file content integrity at each step
#
# Usage:
#   bash test-git-on-mount.sh /path/to/mount/point
#
# The mount must already be running. All test artifacts are created under
# <mount>/git-test-<pid> and cleaned up on exit (unless TEST_KEEP=1).
#
set -euo pipefail

MOUNT_DIR="${1:?Usage: $0 <mount-dir>}"
TEST_DIR="$MOUNT_DIR/git-test-$$"
LOCAL_DIR=$(mktemp -d)
PASS=0
FAIL=0

cleanup() {
    if [[ "${TEST_KEEP:-}" == "1" ]]; then
        echo "TEST_KEEP=1 — leaving artifacts:"
        echo "  mount: $TEST_DIR"
        echo "  local: $LOCAL_DIR"
    else
        rm -rf "$TEST_DIR" 2>/dev/null || true
        rm -rf "$LOCAL_DIR" 2>/dev/null || true
    fi
}
trap cleanup EXIT

# --- helpers ---------------------------------------------------------------

pass() { PASS=$((PASS + 1)); echo "  PASS: $1"; }
fail() { FAIL=$((FAIL + 1)); echo "  FAIL: $1"; }

assert_file_contains() {
    local file=$1 expected=$2 label=$3
    if [[ -f "$file" ]] && grep -qF "$expected" "$file" 2>/dev/null; then
        pass "$label"
    else
        fail "$label (expected '$expected' in $file)"
    fi
}

assert_file_exists() {
    local file=$1 label=$2
    if [[ -f "$file" ]]; then
        pass "$label"
    else
        fail "$label ($file not found)"
    fi
}

assert_file_not_exists() {
    local file=$1 label=$2
    if [[ ! -f "$file" ]]; then
        pass "$label"
    else
        fail "$label ($file should not exist)"
    fi
}

assert_eq() {
    local actual=$1 expected=$2 label=$3
    if [[ "$actual" == "$expected" ]]; then
        pass "$label"
    else
        fail "$label (expected '$expected', got '$actual')"
    fi
}

# --- setup -----------------------------------------------------------------

echo "========================================"
echo "  Git-on-mount integration test"
echo "========================================"
echo "Mount:  $MOUNT_DIR"
echo "Test:   $TEST_DIR"
echo "Local:  $LOCAL_DIR"
echo ""

if ! mountpoint -q "$MOUNT_DIR" 2>/dev/null && [[ ! -d "$MOUNT_DIR" ]]; then
    echo "ERROR: $MOUNT_DIR is not a valid directory"
    exit 1
fi

mkdir -p "$TEST_DIR"

# --- Phase 1: Create bare repo on mount -----------------------------------

echo "--- Phase 1: Create bare repo on mount ---"

BARE_REPO="$TEST_DIR/repo.git"
git init --bare "$BARE_REPO" >/dev/null 2>&1
pass "bare repo created on mount"

# --- Phase 2: Clone locally, make initial commits, push -------------------

echo "--- Phase 2: Clone locally, make initial commits, push ---"

LOCAL_CLONE="$LOCAL_DIR/clone1"
git clone "$BARE_REPO" "$LOCAL_CLONE" >/dev/null 2>&1
cd "$LOCAL_CLONE"
git config user.email "[email protected]"
git config user.name "SeaweedFS Test"

# Commit 1: initial files
echo "hello world" > README.md
mkdir -p src
echo 'package main; import "fmt"; func main() { fmt.Println("v1") }' > src/main.go
git add -A && git commit -m "initial commit" >/dev/null 2>&1
COMMIT1=$(git rev-parse HEAD)

# Commit 2: add more files
mkdir -p data
for i in $(seq 1 20); do
    printf "file-%03d: %s\n" "$i" "$(head -c 64 /dev/urandom | base64)" > "data/file-$(printf '%03d' $i).txt"
done
git add -A && git commit -m "add data files" >/dev/null 2>&1
COMMIT2=$(git rev-parse HEAD)

# Commit 3: modify and add
echo 'package main; import "fmt"; func main() { fmt.Println("v2") }' > src/main.go
echo "# Updated readme" >> README.md
mkdir -p docs
echo "documentation content" > docs/guide.md
git add -A && git commit -m "update src and add docs" >/dev/null 2>&1
COMMIT3=$(git rev-parse HEAD)

git push origin master >/dev/null 2>&1 || git push origin main >/dev/null 2>&1
BRANCH=$(git rev-parse --abbrev-ref HEAD)
pass "3 commits pushed to mount bare repo (branch=$BRANCH)"

# --- Phase 3: Clone from mount bare repo to mount working dir -------------

echo "--- Phase 3: Clone from mount bare repo to on-mount working dir ---"

MOUNT_CLONE="$TEST_DIR/working"
git clone "$BARE_REPO" "$MOUNT_CLONE" >/dev/null 2>&1

# Verify clone integrity
assert_file_exists "$MOUNT_CLONE/README.md" "README.md exists after clone"
assert_file_contains "$MOUNT_CLONE/README.md" "# Updated readme" "README.md has latest content"
assert_file_contains "$MOUNT_CLONE/src/main.go" 'v2' "src/main.go has v2"
assert_file_exists "$MOUNT_CLONE/docs/guide.md" "docs/guide.md exists"
assert_file_exists "$MOUNT_CLONE/data/file-001.txt" "data files exist"
assert_file_exists "$MOUNT_CLONE/data/file-020.txt" "data/file-020.txt exists"

CLONE_HEAD=$(cd "$MOUNT_CLONE" && git rev-parse HEAD)
assert_eq "$CLONE_HEAD" "$COMMIT3" "on-mount clone HEAD matches commit 3"

# Count files
FILE_COUNT=$(find "$MOUNT_CLONE/data" -name '*.txt' | wc -l | tr -d ' ')
assert_eq "$FILE_COUNT" "20" "data/ has 20 files"

# --- Phase 4: Push more commits from local clone --------------------------

echo "--- Phase 4: Push more commits from local clone ---"

cd "$LOCAL_CLONE"

# Commit 4: larger changes
for i in $(seq 21 50); do
    printf "file-%03d: %s\n" "$i" "$(head -c 128 /dev/urandom | base64)" > "data/file-$(printf '%03d' $i).txt"
done
echo 'package main; import "fmt"; func main() { fmt.Println("v3") }' > src/main.go
git add -A && git commit -m "expand data and update to v3" >/dev/null 2>&1
COMMIT4=$(git rev-parse HEAD)

# Commit 5: rename and delete
git mv docs/guide.md docs/manual.md
git rm data/file-001.txt >/dev/null 2>&1
git commit -m "rename guide, remove file-001" >/dev/null 2>&1
COMMIT5=$(git rev-parse HEAD)

git push origin "$BRANCH" >/dev/null 2>&1
pass "2 more commits pushed (5 total)"

# --- Phase 5: Checkout older revision in on-mount clone -------------------

echo "--- Phase 5: Checkout older revision in on-mount clone ---"

cd "$MOUNT_CLONE"
git checkout "$COMMIT2" >/dev/null 2>&1

# Verify we're at commit 2 state
DETACHED_HEAD=$(git rev-parse HEAD)
assert_eq "$DETACHED_HEAD" "$COMMIT2" "on-mount clone at commit 2 (detached)"
assert_file_not_exists "$MOUNT_CLONE/docs/guide.md" "docs/guide.md not in commit 2"
assert_file_contains "$MOUNT_CLONE/src/main.go" 'v1' "src/main.go has v1 at commit 2"

# --- Phase 6: Return to branch and pull -----------------------------------

echo "--- Phase 6: Return to branch and pull with real changes ---"

cd "$MOUNT_CLONE"
git checkout "$BRANCH" >/dev/null 2>&1
# At this point the on-mount clone is at commit 3, remote is at commit 5
OLD_HEAD=$(git rev-parse HEAD)
assert_eq "$OLD_HEAD" "$COMMIT3" "on-mount clone at commit 3 before pull"

git pull >/dev/null 2>&1
NEW_HEAD=$(git rev-parse HEAD)
assert_eq "$NEW_HEAD" "$COMMIT5" "HEAD matches commit 5 after pull"

# Verify commit 5 state
assert_file_contains "$MOUNT_CLONE/src/main.go" 'v3' "src/main.go has v3 after pull"
assert_file_exists "$MOUNT_CLONE/docs/manual.md" "docs/manual.md exists (renamed)"
assert_file_not_exists "$MOUNT_CLONE/docs/guide.md" "docs/guide.md gone (renamed)"
assert_file_not_exists "$MOUNT_CLONE/data/file-001.txt" "data/file-001.txt removed"
assert_file_exists "$MOUNT_CLONE/data/file-050.txt" "data/file-050.txt exists"

FINAL_COUNT=$(find "$MOUNT_CLONE/data" -name '*.txt' | wc -l | tr -d ' ')
assert_eq "$FINAL_COUNT" "49" "data/ has 49 files (50 added, 1 removed)"

# --- Phase 7: Verify git log integrity -----------------------------------

echo "--- Phase 7: Verify git log integrity ---"

cd "$MOUNT_CLONE"
GIT_LOG=$(git log --format=%s)
LOG_COUNT=$(echo "$GIT_LOG" | wc -l | tr -d ' ')
assert_eq "$LOG_COUNT" "5" "git log shows 5 commits"

# Verify commit messages
echo "$GIT_LOG" | grep -qF "initial commit" && pass "commit 1 message in log" || fail "commit 1 message missing"
echo "$GIT_LOG" | grep -qF "expand data" && pass "commit 4 message in log" || fail "commit 4 message missing"
echo "$GIT_LOG" | grep -qF "rename guide" && pass "commit 5 message in log" || fail "commit 5 message missing"

# --- Phase 8: Verify git status is clean ----------------------------------

echo "--- Phase 8: Verify git status is clean ---"

cd "$MOUNT_CLONE"
STATUS=$(git status --porcelain)
if [[ -z "$STATUS" ]]; then
    pass "git status is clean"
else
    fail "git status has changes: $STATUS"
fi

# --- Results ---------------------------------------------------------------

echo ""
echo "========================================"
echo "  Results: $PASS passed, $FAIL failed"
echo "========================================"

if [[ "$FAIL" -gt 0 ]]; then
    exit 1
fi