Proposed Test Scripts for HeliosDB Nano

Created: 2025-12-01 Target Version: v2.5.0

Overview

This document proposes new test scripts to improve test coverage. Each script includes:

Purpose and scope
Test cases to cover
Expected pass criteria
Dependencies

1. test_encryption.sh

Purpose

Comprehensive testing of Transparent Data Encryption (TDE) features.

Scope

Key management
Data encryption/decryption
Performance overhead
Key rotation
Recovery scenarios

Test Cases

#!/bin/bash
# test_encryption.sh - Encryption Feature Test Suite

set -e
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
DB="$SCRIPT_DIR/target/release/heliosdb-nano"
TEST_DIR=$(mktemp -d)

# Colors
GREEN='\033[0;32m'
RED='\033[0;31m'
NC='\033[0m'

pass_count=0
fail_count=0

test_case() {
    local name="$1"
    local result="$2"
    if [ "$result" = "0" ]; then
        echo -e "${GREEN}[PASS]${NC} $name"
        ((pass_count++))
    else
        echo -e "${RED}[FAIL]${NC} $name"
        ((fail_count++))
    fi
}

echo "=== Encryption Test Suite ==="

# Test 1: Create encrypted database
echo "Testing encrypted database creation..."
$DB --data-dir "$TEST_DIR/enc_db" --encryption-key "test-key-32-bytes-long-here!!" <<EOF
CREATE TABLE secrets (id INT, data TEXT);
INSERT INTO secrets VALUES (1, 'sensitive data');
SELECT * FROM secrets;
\q
EOF
test_case "Create encrypted database" $?

# Test 2: Verify data is encrypted at rest
echo "Testing data-at-rest encryption..."
if grep -q "sensitive data" "$TEST_DIR/enc_db/"*.sst 2>/dev/null; then
    test_case "Data-at-rest encryption" 1
else
    test_case "Data-at-rest encryption" 0
fi

# Test 3: Access with correct key
echo "Testing access with correct key..."
$DB --data-dir "$TEST_DIR/enc_db" --encryption-key "test-key-32-bytes-long-here!!" <<EOF
SELECT * FROM secrets WHERE id = 1;
\q
EOF
test_case "Access with correct key" $?

# Test 4: Reject incorrect key
echo "Testing rejection of incorrect key..."
if $DB --data-dir "$TEST_DIR/enc_db" --encryption-key "wrong-key-here!!" <<EOF 2>/dev/null
SELECT * FROM secrets;
\q
EOF
then
    test_case "Reject incorrect key" 1
else
    test_case "Reject incorrect key" 0
fi

# Test 5: Key rotation
echo "Testing key rotation..."
$DB --data-dir "$TEST_DIR/enc_db" --encryption-key "test-key-32-bytes-long-here!!" \
    --rotate-key "new-key-32-bytes-long-here!!!!" <<EOF
SELECT * FROM secrets;
\q
EOF
test_case "Key rotation" $?

# Test 6: Access with rotated key
echo "Testing access with rotated key..."
$DB --data-dir "$TEST_DIR/enc_db" --encryption-key "new-key-32-bytes-long-here!!!!" <<EOF
SELECT * FROM secrets WHERE id = 1;
\q
EOF
test_case "Access with rotated key" $?

# Test 7: Encryption with vector data
echo "Testing encryption with vector data..."
$DB --data-dir "$TEST_DIR/vec_enc_db" --encryption-key "test-key-32-bytes-long-here!!" <<EOF
CREATE TABLE embeddings (id INT, vec VECTOR(3));
INSERT INTO embeddings VALUES (1, '[1.0, 2.0, 3.0]');
SELECT * FROM embeddings;
\q
EOF
test_case "Encryption with vector data" $?

# Test 8: Encrypted index operations
echo "Testing encrypted index operations..."
$DB --data-dir "$TEST_DIR/enc_db" --encryption-key "new-key-32-bytes-long-here!!!!" <<EOF
CREATE INDEX idx_secrets ON secrets(id);
SELECT * FROM secrets WHERE id = 1;
DROP INDEX idx_secrets;
\q
EOF
test_case "Encrypted index operations" $?

# Test 9: Encrypted transactions
echo "Testing encrypted transactions..."
$DB --data-dir "$TEST_DIR/enc_db" --encryption-key "new-key-32-bytes-long-here!!!!" <<EOF
BEGIN;
INSERT INTO secrets VALUES (2, 'more secrets');
COMMIT;
SELECT * FROM secrets;
\q
EOF
test_case "Encrypted transactions" $?

# Test 10: Performance benchmark
echo "Testing encryption performance..."
start_time=$(date +%s%N)
$DB --data-dir "$TEST_DIR/perf_enc_db" --encryption-key "test-key-32-bytes-long-here!!" <<EOF
CREATE TABLE perf_test (id INT, data TEXT);
$(for i in $(seq 1 100); do echo "INSERT INTO perf_test VALUES ($i, 'data $i');"; done)
SELECT COUNT(*) FROM perf_test;
\q
EOF
end_time=$(date +%s%N)
elapsed=$(( (end_time - start_time) / 1000000 ))
if [ "$elapsed" -lt 5000 ]; then
    test_case "Encryption performance (<5s for 100 inserts)" 0
else
    test_case "Encryption performance (<5s for 100 inserts)" 1
fi

# Cleanup
rm -rf "$TEST_DIR"

# Summary
echo ""
echo "=== Test Summary ==="
echo -e "Passed: ${GREEN}$pass_count${NC}"
echo -e "Failed: ${RED}$fail_count${NC}"
total=$((pass_count + fail_count))
echo "Total: $total"

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

Pass Criteria

100% of test cases pass
Performance overhead < 20%

2. test_audit.sh

Purpose

Test audit logging functionality for compliance.

Test Cases

#!/bin/bash
# test_audit.sh - Audit Logging Test Suite

set -e
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
DB="$SCRIPT_DIR/target/release/heliosdb-nano"
TEST_DIR=$(mktemp -d)

GREEN='\033[0;32m'
RED='\033[0;31m'
NC='\033[0m'

pass_count=0
fail_count=0

test_case() {
    local name="$1"
    local result="$2"
    if [ "$result" = "0" ]; then
        echo -e "${GREEN}[PASS]${NC} $name"
        ((pass_count++))
    else
        echo -e "${RED}[FAIL]${NC} $name"
        ((fail_count++))
    fi
}

echo "=== Audit Logging Test Suite ==="

# Test 1: Enable audit logging
echo "Testing audit log initialization..."
$DB --data-dir "$TEST_DIR/audit_db" --audit-log "$TEST_DIR/audit.log" <<EOF
CREATE TABLE users (id INT, name TEXT);
INSERT INTO users VALUES (1, 'Alice');
SELECT * FROM users;
\q
EOF
test_case "Audit log initialization" $?

# Test 2: Verify DDL logging
echo "Testing DDL event logging..."
if grep -q "CREATE TABLE" "$TEST_DIR/audit.log"; then
    test_case "DDL event logging" 0
else
    test_case "DDL event logging" 1
fi

# Test 3: Verify DML logging
echo "Testing DML event logging..."
if grep -q "INSERT" "$TEST_DIR/audit.log"; then
    test_case "DML event logging" 0
else
    test_case "DML event logging" 1
fi

# Test 4: Verify SELECT logging
echo "Testing SELECT event logging..."
if grep -q "SELECT" "$TEST_DIR/audit.log"; then
    test_case "SELECT event logging" 0
else
    test_case "SELECT event logging" 1
fi

# Test 5: Log format validation
echo "Testing log format (JSON)..."
if head -1 "$TEST_DIR/audit.log" | jq . >/dev/null 2>&1; then
    test_case "Log format validation (JSON)" 0
else
    test_case "Log format validation (JSON)" 1
fi

# Test 6: Timestamp presence
echo "Testing timestamp presence..."
if grep -q "timestamp" "$TEST_DIR/audit.log"; then
    test_case "Timestamp presence" 0
else
    test_case "Timestamp presence" 1
fi

# Test 7: User tracking
echo "Testing user tracking..."
$DB --data-dir "$TEST_DIR/audit_db" --audit-log "$TEST_DIR/audit.log" --user "testuser" <<EOF
UPDATE users SET name = 'Bob' WHERE id = 1;
\q
EOF
if grep -q "testuser" "$TEST_DIR/audit.log"; then
    test_case "User tracking" 0
else
    test_case "User tracking" 1
fi

# Test 8: Audit log query
echo "Testing audit log query..."
$DB --data-dir "$TEST_DIR/audit_db" --audit-log "$TEST_DIR/audit.log" <<EOF
SELECT * FROM heliosdb_audit_log LIMIT 5;
\q
EOF
test_case "Audit log query" $?

# Test 9: Log rotation
echo "Testing log rotation..."
for i in $(seq 1 1000); do
    echo "INSERT INTO users VALUES ($i, 'User$i');"
done | $DB --data-dir "$TEST_DIR/audit_db" --audit-log "$TEST_DIR/audit.log" --audit-max-size 10000
if [ -f "$TEST_DIR/audit.log.1" ] || [ $(wc -c < "$TEST_DIR/audit.log") -lt 50000 ]; then
    test_case "Log rotation" 0
else
    test_case "Log rotation" 1
fi

# Test 10: Tamper detection
echo "Testing tamper detection..."
original_hash=$(sha256sum "$TEST_DIR/audit.log" | cut -d' ' -f1)
echo "tampered line" >> "$TEST_DIR/audit.log"
$DB --data-dir "$TEST_DIR/audit_db" --audit-log "$TEST_DIR/audit.log" --verify-audit <<EOF
SELECT 1;
\q
EOF
# Should warn about tampered log
test_case "Tamper detection" $?

# Cleanup
rm -rf "$TEST_DIR"

echo ""
echo "=== Test Summary ==="
echo -e "Passed: ${GREEN}$pass_count${NC}"
echo -e "Failed: ${RED}$fail_count${NC}"

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

3. test_materialized_views.sh

Purpose

Test materialized view creation, refresh, and query functionality.

Test Cases

#!/bin/bash
# test_materialized_views.sh - Materialized Views Test Suite

set -e
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
DB="$SCRIPT_DIR/target/release/heliosdb-nano"
TEST_DIR=$(mktemp -d)

GREEN='\033[0;32m'
RED='\033[0;31m'
NC='\033[0m'

pass_count=0
fail_count=0

test_case() {
    local name="$1"
    local result="$2"
    if [ "$result" = "0" ]; then
        echo -e "${GREEN}[PASS]${NC} $name"
        ((pass_count++))
    else
        echo -e "${RED}[FAIL]${NC} $name"
        ((fail_count++))
    fi
}

echo "=== Materialized Views Test Suite ==="

# Setup base tables
$DB --data-dir "$TEST_DIR/mv_db" <<EOF
CREATE TABLE orders (id INT, customer_id INT, amount DECIMAL(10,2), created_at TIMESTAMP);
CREATE TABLE customers (id INT, name TEXT, region TEXT);
INSERT INTO customers VALUES (1, 'Alice', 'North'), (2, 'Bob', 'South'), (3, 'Charlie', 'North');
INSERT INTO orders VALUES (1, 1, 100.00, '2025-01-01 10:00:00');
INSERT INTO orders VALUES (2, 1, 200.00, '2025-01-02 11:00:00');
INSERT INTO orders VALUES (3, 2, 150.00, '2025-01-01 09:00:00');
INSERT INTO orders VALUES (4, 3, 300.00, '2025-01-03 14:00:00');
\q
EOF

# Test 1: Create materialized view
echo "Testing MV creation..."
$DB --data-dir "$TEST_DIR/mv_db" <<EOF
CREATE MATERIALIZED VIEW customer_totals AS
SELECT c.name, c.region, SUM(o.amount) as total_spent
FROM customers c
JOIN orders o ON c.id = o.customer_id
GROUP BY c.name, c.region;
\q
EOF
test_case "Create materialized view" $?

# Test 2: Query materialized view
echo "Testing MV query..."
result=$($DB --data-dir "$TEST_DIR/mv_db" <<EOF
SELECT * FROM customer_totals ORDER BY total_spent DESC;
\q
EOF
)
if echo "$result" | grep -q "Alice.*300"; then
    test_case "Query materialized view" 0
else
    test_case "Query materialized view" 1
fi

# Test 3: MV with WHERE clause
echo "Testing MV query with WHERE..."
$DB --data-dir "$TEST_DIR/mv_db" <<EOF
SELECT * FROM customer_totals WHERE region = 'North';
\q
EOF
test_case "MV query with WHERE" $?

# Test 4: Manual refresh
echo "Testing manual refresh..."
$DB --data-dir "$TEST_DIR/mv_db" <<EOF
INSERT INTO orders VALUES (5, 1, 500.00, '2025-01-04 10:00:00');
REFRESH MATERIALIZED VIEW customer_totals;
SELECT * FROM customer_totals WHERE name = 'Alice';
\q
EOF
test_case "Manual refresh" $?

# Test 5: Auto-refresh configuration
echo "Testing auto-refresh configuration..."
$DB --data-dir "$TEST_DIR/mv_db" <<EOF
CREATE MATERIALIZED VIEW daily_totals
WITH (auto_refresh = true, refresh_interval = '1 minute')
AS SELECT DATE(created_at) as day, SUM(amount) as daily_total
FROM orders GROUP BY DATE(created_at);
\dmv
\q
EOF
test_case "Auto-refresh configuration" $?

# Test 6: Incremental refresh
echo "Testing incremental refresh..."
$DB --data-dir "$TEST_DIR/mv_db" <<EOF
CREATE MATERIALIZED VIEW order_count
WITH (incremental = true)
AS SELECT customer_id, COUNT(*) as order_count
FROM orders GROUP BY customer_id;
INSERT INTO orders VALUES (6, 2, 75.00, '2025-01-05 11:00:00');
REFRESH MATERIALIZED VIEW order_count;
SELECT * FROM order_count;
\q
EOF
test_case "Incremental refresh" $?

# Test 7: System view for MV staleness
echo "Testing pg_mv_staleness view..."
result=$($DB --data-dir "$TEST_DIR/mv_db" <<EOF
SELECT * FROM pg_mv_staleness();
\q
EOF
)
if echo "$result" | grep -q "customer_totals"; then
    test_case "pg_mv_staleness view" 0
else
    test_case "pg_mv_staleness view" 1
fi

# Test 8: Drop materialized view
echo "Testing MV drop..."
$DB --data-dir "$TEST_DIR/mv_db" <<EOF
DROP MATERIALIZED VIEW daily_totals;
\dmv
\q
EOF
test_case "Drop materialized view" $?

# Test 9: MV with vector data
echo "Testing MV with aggregated vectors..."
$DB --data-dir "$TEST_DIR/mv_db" <<EOF
CREATE TABLE documents (id INT, category TEXT, embedding VECTOR(3));
INSERT INTO documents VALUES (1, 'tech', '[1.0, 0.0, 0.0]');
INSERT INTO documents VALUES (2, 'tech', '[0.9, 0.1, 0.0]');
CREATE MATERIALIZED VIEW category_count AS
SELECT category, COUNT(*) as doc_count FROM documents GROUP BY category;
SELECT * FROM category_count;
\q
EOF
test_case "MV with vector tables" $?

# Test 10: Concurrent refresh test
echo "Testing concurrent refresh..."
$DB --data-dir "$TEST_DIR/mv_db" <<EOF
REFRESH MATERIALIZED VIEW CONCURRENTLY customer_totals;
SELECT * FROM customer_totals;
\q
EOF
test_case "Concurrent refresh" $?

# Cleanup
rm -rf "$TEST_DIR"

echo ""
echo "=== Test Summary ==="
echo -e "Passed: ${GREEN}$pass_count${NC}"
echo -e "Failed: ${RED}$fail_count${NC}"

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

4. test_vector_search.sh

Purpose

Comprehensive vector search testing including HNSW indexing and similarity search.

Test Cases

#!/bin/bash
# test_vector_search.sh - Vector Search Test Suite

set -e
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
DB="$SCRIPT_DIR/target/release/heliosdb-nano"
TEST_DIR=$(mktemp -d)

GREEN='\033[0;32m'
RED='\033[0;31m'
NC='\033[0m'

pass_count=0
fail_count=0

test_case() {
    local name="$1"
    local result="$2"
    if [ "$result" = "0" ]; then
        echo -e "${GREEN}[PASS]${NC} $name"
        ((pass_count++))
    else
        echo -e "${RED}[FAIL]${NC} $name"
        ((fail_count++))
    fi
}

echo "=== Vector Search Test Suite ==="

# Test 1: Create table with vector column
echo "Testing vector table creation..."
$DB --data-dir "$TEST_DIR/vec_db" <<EOF
CREATE TABLE documents (
    id INT PRIMARY KEY,
    title TEXT,
    embedding VECTOR(384)
);
\q
EOF
test_case "Vector table creation" $?

# Test 2: Insert vectors
echo "Testing vector insertion..."
$DB --data-dir "$TEST_DIR/vec_db" <<EOF
INSERT INTO documents VALUES (1, 'Machine Learning', '[$(python3 -c "print(','.join(['0.1']*384))")]');
INSERT INTO documents VALUES (2, 'Deep Learning', '[$(python3 -c "print(','.join(['0.2']*384))")]');
INSERT INTO documents VALUES (3, 'Neural Networks', '[$(python3 -c "print(','.join(['0.15']*384))")]');
SELECT COUNT(*) FROM documents;
\q
EOF
test_case "Vector insertion" $?

# Test 3: Create HNSW index
echo "Testing HNSW index creation..."
$DB --data-dir "$TEST_DIR/vec_db" <<EOF
CREATE INDEX idx_docs_embedding ON documents USING hnsw (embedding);
\q
EOF
test_case "HNSW index creation" $?

# Test 4: Cosine similarity search
echo "Testing cosine similarity search..."
result=$($DB --data-dir "$TEST_DIR/vec_db" <<EOF
SELECT id, title, cosine_similarity(embedding, '[$(python3 -c "print(','.join(['0.1']*384))")]') as score
FROM documents
ORDER BY score DESC
LIMIT 3;
\q
EOF
)
if echo "$result" | grep -q "Machine Learning"; then
    test_case "Cosine similarity search" 0
else
    test_case "Cosine similarity search" 1
fi

# Test 5: L2 distance search
echo "Testing L2 distance search..."
$DB --data-dir "$TEST_DIR/vec_db" <<EOF
SELECT id, title, l2_distance(embedding, '[$(python3 -c "print(','.join(['0.2']*384))")]') as distance
FROM documents
ORDER BY distance ASC
LIMIT 3;
\q
EOF
test_case "L2 distance search" $?

# Test 6: KNN search
echo "Testing KNN search..."
$DB --data-dir "$TEST_DIR/vec_db" <<EOF
SELECT * FROM documents
ORDER BY embedding <-> '[$(python3 -c "print(','.join(['0.1']*384))")]'
LIMIT 2;
\q
EOF
test_case "KNN search" $?

# Test 7: Vector index stats
echo "Testing pg_vector_index_stats..."
result=$($DB --data-dir "$TEST_DIR/vec_db" <<EOF
SELECT * FROM pg_vector_index_stats();
\q
EOF
)
if echo "$result" | grep -q "idx_docs_embedding"; then
    test_case "pg_vector_index_stats" 0
else
    test_case "pg_vector_index_stats" 1
fi

# Test 8: Batch vector insert
echo "Testing batch vector insert..."
$DB --data-dir "$TEST_DIR/vec_db" <<EOF
INSERT INTO documents VALUES
    (4, 'Computer Vision', '[$(python3 -c "print(','.join(['0.3']*384))")]'),
    (5, 'NLP', '[$(python3 -c "print(','.join(['0.25']*384))")]'),
    (6, 'Robotics', '[$(python3 -c "print(','.join(['0.35']*384))")]');
SELECT COUNT(*) FROM documents;
\q
EOF
test_case "Batch vector insert" $?

# Test 9: Vector with filter
echo "Testing vector search with filter..."
$DB --data-dir "$TEST_DIR/vec_db" <<EOF
SELECT id, title FROM documents
WHERE id > 2
ORDER BY embedding <-> '[$(python3 -c "print(','.join(['0.3']*384))")]'
LIMIT 2;
\q
EOF
test_case "Vector search with filter" $?

# Test 10: Product Quantization index
echo "Testing PQ index creation..."
$DB --data-dir "$TEST_DIR/vec_db" <<EOF
CREATE INDEX idx_docs_pq ON documents USING hnsw_pq (embedding)
WITH (num_subvectors = 8, bits_per_code = 8);
\q
EOF
test_case "Product Quantization index" $?

# Cleanup
rm -rf "$TEST_DIR"

echo ""
echo "=== Test Summary ==="
echo -e "Passed: ${GREEN}$pass_count${NC}"
echo -e "Failed: ${RED}$fail_count${NC}"

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

5. test_rest_api.sh

Purpose

Test the new REST API for branch management.

Test Cases

#!/bin/bash
# test_rest_api.sh - REST API Test Suite

set -e
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
DB="$SCRIPT_DIR/target/release/heliosdb-nano"
TEST_DIR=$(mktemp -d)
API_PORT=8080
BASE_URL="http://localhost:$API_PORT/v1"

GREEN='\033[0;32m'
RED='\033[0;31m'
YELLOW='\033[1;33m'
NC='\033[0m'

pass_count=0
fail_count=0

test_case() {
    local name="$1"
    local result="$2"
    if [ "$result" = "0" ]; then
        echo -e "${GREEN}[PASS]${NC} $name"
        ((pass_count++))
    else
        echo -e "${RED}[FAIL]${NC} $name"
        ((fail_count++))
    fi
}

# Start API server
echo -e "${YELLOW}Starting API server...${NC}"
$DB --data-dir "$TEST_DIR/api_db" --api-server --port $API_PORT &
SERVER_PID=$!
sleep 2

# Cleanup function
cleanup() {
    echo "Cleaning up..."
    kill $SERVER_PID 2>/dev/null || true
    rm -rf "$TEST_DIR"
}
trap cleanup EXIT

echo "=== REST API Test Suite ==="

# Test 1: List branches (empty)
echo "Testing list branches..."
result=$(curl -s "$BASE_URL/branches")
if echo "$result" | jq -e '.success == true' >/dev/null; then
    test_case "List branches (initial)" 0
else
    test_case "List branches (initial)" 1
fi

# Test 2: Create branch
echo "Testing create branch..."
result=$(curl -s -X POST "$BASE_URL/branches" \
    -H "Content-Type: application/json" \
    -d '{"name": "feature-test", "source_branch": "main", "as_of": {"type": "now"}}')
if echo "$result" | jq -e '.success == true' >/dev/null; then
    test_case "Create branch" 0
else
    test_case "Create branch" 1
fi

# Test 3: Get branch details
echo "Testing get branch details..."
result=$(curl -s "$BASE_URL/branches/feature-test")
if echo "$result" | jq -e '.data.name == "feature-test"' >/dev/null; then
    test_case "Get branch details" 0
else
    test_case "Get branch details" 1
fi

# Test 4: Execute query on branch
echo "Testing query execution..."
result=$(curl -s -X POST "$BASE_URL/branches/feature-test/query" \
    -H "Content-Type: application/json" \
    -d '{"sql": "SELECT 1 as test"}')
if echo "$result" | jq -e '.success == true' >/dev/null; then
    test_case "Query execution" 0
else
    test_case "Query execution" 1
fi

# Test 5: Create table via execute
echo "Testing DDL execution..."
result=$(curl -s -X POST "$BASE_URL/branches/feature-test/execute" \
    -H "Content-Type: application/json" \
    -d '{"sql": "CREATE TABLE test_table (id INT, name TEXT)"}')
if echo "$result" | jq -e '.success == true' >/dev/null; then
    test_case "DDL execution" 0
else
    test_case "DDL execution" 1
fi

# Test 6: Insert data
echo "Testing data insert..."
result=$(curl -s -X POST "$BASE_URL/branches/feature-test/tables/test_table/data" \
    -H "Content-Type: application/json" \
    -d '{"rows": [{"id": 1, "name": "Alice"}, {"id": 2, "name": "Bob"}]}')
if echo "$result" | jq -e '.data.inserted == 2' >/dev/null; then
    test_case "Data insert" 0
else
    test_case "Data insert" 1
fi

# Test 7: Query data
echo "Testing data query..."
result=$(curl -s "$BASE_URL/branches/feature-test/tables/test_table/data")
if echo "$result" | jq -e '.data.row_count == 2' >/dev/null; then
    test_case "Data query" 0
else
    test_case "Data query" 1
fi

# Test 8: Update data
echo "Testing data update..."
result=$(curl -s -X PUT "$BASE_URL/branches/feature-test/tables/test_table/data" \
    -H "Content-Type: application/json" \
    -d '{"filter": "id = 1", "updates": {"name": "Alice Updated"}}')
if echo "$result" | jq -e '.data.updated == 1' >/dev/null; then
    test_case "Data update" 0
else
    test_case "Data update" 1
fi

# Test 9: Get branch history
echo "Testing branch history..."
result=$(curl -s "$BASE_URL/branches/feature-test/history")
if echo "$result" | jq -e '.success == true' >/dev/null; then
    test_case "Branch history" 0
else
    test_case "Branch history" 1
fi

# Test 10: Create second branch
echo "Testing create second branch..."
result=$(curl -s -X POST "$BASE_URL/branches" \
    -H "Content-Type: application/json" \
    -d '{"name": "feature-merge-test", "source_branch": "main"}')
if echo "$result" | jq -e '.success == true' >/dev/null; then
    test_case "Create second branch" 0
else
    test_case "Create second branch" 1
fi

# Test 11: Merge branches
echo "Testing branch merge..."
result=$(curl -s -X POST "$BASE_URL/branches/feature-test/merge" \
    -H "Content-Type: application/json" \
    -d '{"target_branch": "main", "conflict_resolution": "source_wins"}')
if echo "$result" | jq -e '.data.status == "merged"' >/dev/null; then
    test_case "Branch merge" 0
else
    test_case "Branch merge" 1
fi

# Test 12: Delete branch
echo "Testing delete branch..."
result=$(curl -s -X DELETE "$BASE_URL/branches/feature-merge-test")
if echo "$result" | jq -e '.data.deleted == true' >/dev/null; then
    test_case "Delete branch" 0
else
    test_case "Delete branch" 1
fi

# Test 13: Error handling (non-existent branch)
echo "Testing error handling..."
result=$(curl -s "$BASE_URL/branches/non-existent")
if echo "$result" | jq -e '.success == false' >/dev/null; then
    test_case "Error handling" 0
else
    test_case "Error handling" 1
fi

# Test 14: Rate limiting
echo "Testing rate limiting..."
for i in $(seq 1 150); do
    curl -s "$BASE_URL/branches" >/dev/null
done
result=$(curl -s -w "%{http_code}" -o /dev/null "$BASE_URL/branches")
# Should eventually get 429 if rate limiting works
test_case "Rate limiting (informational)" 0

# Test 15: Time-travel query
echo "Testing time-travel via API..."
result=$(curl -s -X POST "$BASE_URL/branches/main/query" \
    -H "Content-Type: application/json" \
    -d '{"sql": "SELECT * FROM test_table", "as_of": {"type": "now"}}')
if echo "$result" | jq -e '.success == true' >/dev/null; then
    test_case "Time-travel query" 0
else
    test_case "Time-travel query" 1
fi

echo ""
echo "=== Test Summary ==="
echo -e "Passed: ${GREEN}$pass_count${NC}"
echo -e "Failed: ${RED}$fail_count${NC}"

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

Additional Test Scripts Summary

Script	Purpose	Est. Tests	Priority
`test_postgres_protocol.sh`	PostgreSQL wire protocol	15	MEDIUM
`test_scram_auth.sh`	SCRAM-SHA-256 auth	10	MEDIUM
`test_ssl_tls.sh`	SSL/TLS connections	10	MEDIUM
`test_multi_tenancy.sh`	Multi-tenant isolation	12	MEDIUM
`test_query_optimizer.sh`	Query optimization	15	LOW
`test_index_recommender.sh`	Index recommendations	8	LOW

Test Execution

Run All Tests

./run_all_tests.sh

Run Specific Category

./test_encryption.sh
./test_audit.sh
./test_materialized_views.sh
./test_vector_search.sh
./test_rest_api.sh

CI/CD Integration

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Build
        run: cargo build --release
      - name: Run Test Scripts
        run: |
          ./test_core_sql.sh
          ./test_encryption.sh
          ./test_audit.sh
          ./test_materialized_views.sh
          ./test_vector_search.sh

Document Version: 1.0 Last Updated: 2025-12-01