test: auto-generate test files, verify content, CLI args, test_data dir

- test.py generates its own test files in test_data/ (small.txt, medium.txt,
  binary.bin, nested subtree)
- source and dest directories configurable via --source-dir / --dest-dir
- verifies all transferred files match originals byte-for-byte after each test
- waits for server to finish before verification (fixes race in multithreaded)
- all test data lives under test_data/ and is cleaned up unless --keep-data

test.py

@@ -1,27 +1,31 @@
+import argparse
+import filecmp
 import os
+import shutil
 import subprocess
+import sys
+import tempfile
 import time
 
-# --- Configuration ---
+TEST_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "test_data")
+DEFAULT_SOURCE_DIR = os.path.join(TEST_DIR, "source")
+DEFAULT_DEST_DIR = os.path.join(TEST_DIR, "dest")
+
 SERVER_CMD = ["./build/server"]
 base_client_cmd = ["./build/client"]
 
-# --- Resource Limit Configuration ---
+DISK_DEVICE = "/dev/nvme0n1p5"
-# 💾 Disk throttling settings
+READ_BPS_MAX = "15M"
-DISK_DEVICE = (
+WRITE_BPS_MAX = "10M"
-    "/dev/nvme0n1p5"  # IMPORTANT: Change this to your disk (e.g., /dev/nvme0n1)
-)
-READ_BPS_MAX = "15M"  # Max read speed (M for megabytes)
-WRITE_BPS_MAX = "10M"  # Max write speed
 
-# 🐢 Network throttling settings (Linux tc)
 NET_LIMIT = "100mbit"
 NET_DELAY = "100ms"
 NETWORK_INTERFACE = "lo"
-NET_LIMIT_CMD = f"sudo tc qdisc add dev {NETWORK_INTERFACE} root netem rate {NET_LIMIT} delay {NET_DELAY}".split()
+NET_LIMIT_CMD = (
+    f"sudo tc qdisc add dev {NETWORK_INTERFACE} root netem rate {NET_LIMIT} delay {NET_DELAY}".split()
+)
 NET_RESET_CMD = f"sudo tc qdisc del dev {NETWORK_INTERFACE} root".split()
 
-# --- Build the client command prefix with throttling ---
 CLIENT_CMD_PREFIX = [
     "sudo",
     "systemd-run",
@@ -32,7 +36,6 @@ CLIENT_CMD_PREFIX = [
     f"IOWriteBandwidthMax={DISK_DEVICE} {WRITE_BPS_MAX}",
 ]
 
-# --- Test Cases ---
 TEST_CASES = [
     {"name": "Standard (Single-threaded)", "flags": []},
     {"name": "Multithreading (-m)", "flags": ["-m"]},
@@ -48,179 +51,229 @@ TEST_CASES = [
 ]
 
 
-def run_suite(env_name, apply_limits):
+def generate_test_files(source_dir):
+    if os.path.exists(source_dir):
+        shutil.rmtree(source_dir)
+    os.makedirs(source_dir)
+
+    files = {
+        "small.txt": b"hello world\n",
+        "medium.txt": b"line\n" * 1000,
+        "binary.bin": bytes(range(256)),
+        "nested/subdir/deep.txt": b"deeply nested file\n",
+        "nested/another.txt": b"another nested file\n" * 50,
+    }
+    for rel_path, content in files.items():
+        full_path = os.path.join(source_dir, rel_path)
+        os.makedirs(os.path.dirname(full_path), exist_ok=True)
+        with open(full_path, "wb") as f:
+            f.write(content)
+
+
+def verify_transfer(source_dir, dest_dir):
+    source_dir = os.path.abspath(source_dir)
+    dest_dir = os.path.abspath(dest_dir)
+
+    received_prefix = os.path.join(dest_dir, source_dir.lstrip(os.sep))
+    if not os.path.exists(received_prefix):
+        return [], ["no received files found"]
+
+    mismatches = []
+    missing = []
+
+    for root, dirs, files in os.walk(source_dir):
+        for f in files:
+            src_path = os.path.join(root, f)
+            rel = os.path.relpath(src_path, source_dir)
+            dst_path = os.path.join(received_prefix, rel)
+
+            if not os.path.exists(dst_path):
+                missing.append(rel)
+            elif not filecmp.cmp(src_path, dst_path, shallow=False):
+                mismatches.append(rel)
+
+    return mismatches, missing
+
+
+def run_suite(env_name, apply_limits, source_dir, dest_dir):
     results = []
     print(f"\n{'=' * 60}")
-    print(f"🚀 Starting Suite: {env_name}")
+    print(f"Suite: {env_name}")
     print(f"{'=' * 60}")
 
     if apply_limits:
-        print(
+        print(f"  Disk I/O: Reads <= {READ_BPS_MAX}, Writes <= {WRITE_BPS_MAX}")
-            f"Applying Disk I/O Limits: Reads <= {READ_BPS_MAX}, Writes <= {WRITE_BPS_MAX}"
+        print(f"  Network: {NET_LIMIT}, {NET_DELAY} delay")
-        )
-        print(f"Applying Network Limits: {NET_LIMIT}, {NET_DELAY} delay")
         client_prefix = CLIENT_CMD_PREFIX
     else:
-        print("Running Baseline (No limits applied)")
+        print("  Baseline (no limits)")
-        client_prefix = []  # Run normally without systemd-run/limits
+        client_prefix = []
 
     try:
-        # SETUP: Apply or ensure clean network limits
         if apply_limits:
             subprocess.run(NET_LIMIT_CMD, check=True)
         else:
-            # Silently attempt to clear any leftover rules just to ensure a clean baseline
             subprocess.run(NET_RESET_CMD, capture_output=True)
 
         for case in TEST_CASES:
             name = case["name"]
             flags = case["flags"]
+            print(f"\n  --- {name} ---")
 
-            print(f"\n--- Running: {name} ---")
+            if os.path.exists(dest_dir):
+                shutil.rmtree(dest_dir)
 
             server_process = None
             try:
-                # 1. Start the server
-                print("  Starting server...")
                 server_process = subprocess.Popen(
                     SERVER_CMD, stdout=subprocess.DEVNULL, stderr=None
                 )
-                time.sleep(0.5)  # Allow server to bind to port
+                time.sleep(0.5)
+
+                env = os.environ.copy()
+                env["FASTSYNC_SOURCE_DIR"] = source_dir
+                env["FASTSYNC_DEST_DIR"] = dest_dir
+                env["FASTSYNC_SAVE_TO_DISK"] = "true"
 
-                # 2. Build and run the client
                 client_cmd = client_prefix + base_client_cmd + flags
-                print(f"  Running client: {' '.join(client_cmd)}")
+                print(f"    Running: {' '.join(client_cmd)}")
 
                 start_time = time.monotonic()
                 client_result = subprocess.run(
-                    client_cmd, text=True, capture_output=True
+                    client_cmd, env=env, text=True, capture_output=True
                 )
                 end_time = time.monotonic()
-
                 duration = end_time - start_time
 
+                if server_process:
+                    try:
+                        server_process.wait(timeout=5)
+                    except subprocess.TimeoutExpired:
+                        server_process.kill()
+                        server_process.wait()
+                    server_process = None
+
+                mismatches, missing = [], []
                 if client_result.returncode == 0:
-                    results.append(
+                    mismatches, missing = verify_transfer(source_dir, dest_dir)
-                        {
+
-                            "environment": env_name,
+                entry = {
-                            "name": name,
+                    "name": name,
-                            "status": "Success",
+                    "suite": env_name,
-                            "time": f"{duration:.4f}s",
+                    "time": f"{duration:.4f}s" if client_result.returncode == 0 else "N/A",
-                            "error": "",
+                }
-                        }
+
-                    )
+                if client_result.returncode == 0 and not mismatches and not missing:
+                    entry["status"] = "Success"
+                    entry["error"] = ""
                 else:
-                    print(f"  ⚠️ Failed (code: {client_result.returncode})")
+                    entry["status"] = "Failed"
-                    err_msg = (
+                    errors = []
-                        client_result.stderr.strip().split("\n")[0]
+                    if client_result.returncode != 0:
-                        if client_result.stderr
+                        err = (
-                        else (
+                            client_result.stderr.strip().split("\n")[0]
-                            client_result.stdout.strip().split("\n")[0]
+                            if client_result.stderr
-                            if client_result.stdout
+                            else (
-                            else "No output"
+                                client_result.stdout.strip().split("\n")[0]
+                                if client_result.stdout
+                                else "No output"
+                            )
                         )
-                    )
+                        errors.append(f"Exit code {client_result.returncode}: {err[:80]}")
-                    results.append(
+                    if missing:
-                        {
+                        errors.append(f"Missing ({len(missing)}): {', '.join(missing[:5])}")
-                            "environment": env_name,
+                    if mismatches:
-                            "name": name,
+                        errors.append(f"Mismatch ({len(mismatches)}): {', '.join(mismatches[:3])}")
-                            "status": "Failed",
+                    entry["error"] = " | ".join(errors)
-                            "time": "N/A",
+
-                            "error": f"Exit code {client_result.returncode}: {err_msg[:40]}",
+                results.append(entry)
-                        }
-                    )
 
             except subprocess.TimeoutExpired:
-                print("  ⚠️ Timeout (exceeded 15s)")
                 results.append(
-                    {
+                    {"name": name, "status": "Timeout", "time": "N/A", "error": "Exceeded 15s"}
-                        "environment": env_name,
-                        "name": name,
-                        "status": "Timeout",
-                        "time": "N/A",
-                        "error": "Exceeded 15 seconds",
-                    }
                 )
             except Exception as e:
-                print(f"  ❌ Error: {e}")
                 results.append(
-                    {
+                    {"name": name, "status": "Error", "time": "N/A", "error": str(e)}
-                        "environment": env_name,
-                        "name": name,
-                        "status": "Error",
-                        "time": "N/A",
-                        "error": str(e),
-                    }
                 )
             finally:
-                # Clean up the server for this test case
                 if server_process:
-                    print("  Stopping server...")
                     try:
-                        server_process.terminate()
                         server_process.wait(timeout=5)
                     except subprocess.TimeoutExpired:
                         server_process.kill()
                         server_process.wait()
 
     except subprocess.CalledProcessError as e:
-        print(f"❌ Error running system limit command: {' '.join(e.cmd)}")
+        print(f"  Error running limit command: {' '.join(e.cmd)}")
-        print("Are you running this script with 'sudo' privileges?")
-
     finally:
-        # TEARDOWN: Remove network limits if they were applied
         if apply_limits:
-            print("\nCleaning up limits for this suite...")
             try:
                 subprocess.run(NET_RESET_CMD, check=True, capture_output=True)
-                print("Network limits removed.")
+            except Exception:
-            except Exception as e:
+                pass
-                print(f"⚠️ Could not reset network settings: {e}")
 
     return results
 
 
-os.system("cmake -B build -S .")
+def main():
-os.system("cd build && make")
+    parser = argparse.ArgumentParser(description="FastSync integration test / benchmark")
+    parser.add_argument("--source-dir", default=DEFAULT_SOURCE_DIR,
+                        help="Source directory for test files (default: %(default)s)")
+    parser.add_argument("--dest-dir", default=DEFAULT_DEST_DIR,
+                        help="Destination directory for received files (default: %(default)s)")
+    parser.add_argument("--keep-data", action="store_true",
+                        help="Keep test_data directory after run")
+    parser.add_argument("--no-throttled", action="store_true",
+                        help="Skip throttled suite (requires sudo)")
+    parser.add_argument("--no-unlimited", action="store_true",
+                        help="Skip unlimited suite")
+    args = parser.parse_args()
 
-# --- Main Execution ---
+    os.system("cmake -B build -S . > /dev/null 2>&1")
-all_results = []
+    ret = os.system("cd build && make -j$(nproc) 2>&1 | tail -3")
+    if ret != 0:
+        print("Build failed")
+        sys.exit(1)
 
-# 1. Run Baseline (No Limits)
+    generate_test_files(args.source_dir)
-all_results.extend(run_suite("Unlimited", apply_limits=False))
+    os.makedirs(args.dest_dir, exist_ok=True)
 
-# # 2. Run Throttled (With Limits)
+    try:
-all_results.extend(run_suite("Throttled", apply_limits=True))
+        all_results = []
 
-# --- Print Comparison Table ---
+        if not args.no_unlimited:
-print("\n" + "=" * 105)
+            all_results.extend(
-print(f"{'fastSync BENCHMARK RESULTS (COMPARISON)':^105}")
+                run_suite("Unlimited", False, args.source_dir, args.dest_dir)
-print("=" * 105)
+            )
-print(
-    f"{'Configuration':<45} | {'Environment':<12} | {'Status':<10} | {'Time':<10} | {'Details/Error':<20}"
-)
-print("-" * 105)
 
-# Sort results by test case name first, then environment to easily compare
+        if not args.no_throttled:
-# This groups the baseline and throttled results for the same test next to each other
+            all_results.extend(
-# sorted_results = sorted(
+                run_suite("Throttled", True, args.source_dir, args.dest_dir)
-#     all_results,
+            )
-#     key=lambda x: (
-#         TEST_CASES.index(
-#             next(item for item in TEST_CASES if item["name"] == x["name"])
-#         ),
-#         x["environment"],
-#     ),
-# )
 
-for res in all_results:
+        print("\n" + "=" * 110)
-    status_symbol = (
+        print(f"{'RESULTS':^110}")
-        "✅"
+        print("=" * 110)
-        if res["status"] == "Success"
+        print(f"{'Configuration':<45} | {'Suite':<12} | {'Status':<8} | {'Time':<10} | {'Details'}")
-        else ("⏳" if res["status"] == "Timeout" else "❌")
+        print("-" * 110)
-    )
+
-    status_str = f"{status_symbol} {res['status']}"
+        for res in all_results:
-    print(
+            print(
-        f"{res['name']:<45} | {res['environment']:<12} | {status_str:<10} | {res['time']:<10} | {res['error']:<20}"
+                f"{res['name']:<45} | {res['suite']:<12} | {res['status']:<8} | {res['time']:<10} | {res['error']}"
-    )
+            )
-print("=" * 105)
+
+        failed = [r for r in all_results if r["status"] != "Success"]
+        if failed:
+            print(f"\n  {len(failed)} test(s) FAILED")
+            sys.exit(1)
+        else:
+            print(f"\n  ALL {len(all_results)} TESTS PASSED")
+
+    finally:
+        if not args.keep_data:
+            shutil.rmtree(TEST_DIR, ignore_errors=True)
+
+
+if __name__ == "__main__":
+    main()