Week 4: Production Hardening — Thread Safety, Fuzz Tests, Property-Based Tests, NimForum Smoke Test

Thread Safety:
- Add lock to BTreeIndex (insert/get/scan/remove/contains)
- Add lock to InvertedIndex (addDocument/removeDocument/search/bm25/tfidf/fuzzy/regex)
- Add ctxLock to ExecutionContext for DDL/schema metadata, autoIncCounters, sequences
- Deep-copy sessionVars in cloneForConnection() to isolate per-connection state
- Fix activeConnections check-then-act race with Lock

Wire Protocol Hardening:
- Fix RangeDefect in deserializeValue for invalid FieldKind bytes
- Fix IndexDefect in fkFloat32/fkFloat64 by reusing readUint32/readUint64
- Fix int32/int64 cast from uint32/uint64 to use cast[] instead of constructor
- Fix parseHeader to validate MsgKind instead of holey enum cast

Property-Based Tests (tests/prop_test.nim):
- 8 invariants for evalExprValue: literal types, commutativity, identity,
  double negation, NULL propagation

Wire Protocol Fuzz (tests/fuzz_test.nim):
- 7 fuzz tests: random bytes deserialization, truncated buffers,
  MsgKind casts, parseHeader logic, message roundtrips

NimForum Adapter Smoke Test (tests/nimforum_smoke_test.nim):
- Full TCP server lifecycle with adapter CRUD and parameterized queries

Test Results: 423 tests pass, 0 failures

tests/fuzz_test.nim

@@ -0,0 +1,87 @@
+## Wire Protocol Fuzz Tests
+import std/unittest
+import std/random
+import std/strutils
+
+import barabadb/protocol/wire
+
+suite "Wire Protocol Fuzz":
+  test "deserializeValue survives random bytes":
+    var rng = initRand(12345)
+    for i in 0..<500:
+      var buf = newSeq[byte](rng.rand(1..256))
+      for b in buf.mitems:
+        b = byte(rng.rand(0..255))
+      var pos = 0
+      try:
+        discard deserializeValue(buf, pos)
+      except:
+        discard  # Exceptions are expected for garbage input
+
+  test "deserializeValue survives truncated buffers":
+    var rng = initRand(12346)
+    for i in 0..<200:
+      # Start with a valid-ish prefix then truncate
+      var buf: seq[byte] = @[byte(rng.rand(0..12))]  # random FieldKind
+      let extra = rng.rand(0..64)
+      for j in 0..<extra:
+        buf.add(byte(rng.rand(0..255)))
+      var pos = 0
+      try:
+        discard deserializeValue(buf, pos)
+      except:
+        discard
+
+  test "MsgKind cast with random uint32 values":
+    var rng = initRand(12347)
+    for i in 0..<1000:
+      let raw = uint32(rng.rand(int64(high(uint32))))
+      let kind = cast[MsgKind](raw)
+      # Should not crash; cast is unsafe but does not range-check
+      check true
+
+  test "parseHeader-like logic with random 12-byte chunks":
+    var rng = initRand(12348)
+    for i in 0..<500:
+      var data = ""
+      for j in 0..<12:
+        data.add(char(rng.rand(0..255)))
+      let rawKind = uint32(ord(data[0])) shl 24 or uint32(ord(data[1])) shl 16 or
+                    uint32(ord(data[2])) shl 8 or uint32(ord(data[3]))
+      let kind = cast[MsgKind](rawKind)
+      let length = uint32(ord(data[4])) shl 24 or uint32(ord(data[5])) shl 16 or
+                   uint32(ord(data[6])) shl 8 or uint32(ord(data[7]))
+      let requestId = uint32(ord(data[8])) shl 24 or uint32(ord(data[9])) shl 16 or
+                      uint32(ord(data[10])) shl 8 or uint32(ord(data[11]))
+      let header = MessageHeader(kind: kind, length: length, requestId: requestId)
+      check header.length == length
+
+  test "makeQueryMessage roundtrip with random queries":
+    var rng = initRand(12349)
+    for i in 0..<100:
+      var query = ""
+      let len = rng.rand(0..200)
+      for j in 0..<len:
+        query.add(char(rng.rand(32..126)))
+      let msg = makeQueryMessage(uint32(i), query)
+      check msg.len >= 12
+
+  test "serializeMessage roundtrip with random payloads":
+    var rng = initRand(12350)
+    for i in 0..<100:
+      let reqId = uint32(rng.rand(int64(high(uint32))))
+      var msg = WireMessage(
+        header: MessageHeader(kind: mkQuery, length: uint32(rng.rand(0..1000)), requestId: reqId),
+        payload: newSeq[byte](rng.rand(0..200))
+      )
+      for j in 0..<msg.payload.len:
+        msg.payload[j] = byte(rng.rand(0..255))
+      let s = serializeMessage(msg)
+      check s.len >= 12
+
+  test "makeErrorMessage with large IDs":
+    var rng = initRand(12351)
+    for i in 0..<100:
+      let reqId = uint32(rng.rand(int64(high(uint32))))
+      let err = makeErrorMessage(reqId, uint32(rng.rand(0..255)), "fuzz")
+      check err.len > 0

tests/nimforum_smoke_test.nim

@@ -0,0 +1,69 @@
+## NimForum Adapter Smoke Test
+import std/unittest
+import std/osproc
+import std/os
+import std/strutils
+import std/strtabs
+import std/times
+
+import ../adaptors/nim/baradb_sqlite as sqlite
+
+suite "NimForum Adapter Smoke Test":
+  var serverProcess: Process
+  var port: int
+  var dataDir: string
+
+  setup:
+    port = 35000 + (getTime().toUnix.int mod 10000)
+    dataDir = getTempDir() / "baradb_nimforum_" & $port
+    createDir(dataDir)
+    var env = newStringTable()
+    for key, val in envPairs():
+      env[key] = val
+    env["BARADB_PORT"] = $port
+    env["BARADB_DATA_DIR"] = dataDir
+    env["BARADB_LOG_LEVEL"] = "error"
+    serverProcess = startProcess("./build/baradadb", env=env, options={poStdErrToStdOut, poDaemon})
+    sleep(800)
+
+  teardown:
+    if serverProcess != nil:
+      serverProcess.terminate()
+      discard serverProcess.waitForExit()
+    removeDir(dataDir)
+
+  test "Adapter basic CRUD over TCP":
+    var db = open("127.0.0.1:" & $port, "", "", "default")
+
+    db.exec(sql"CREATE TABLE nf_test (id INT PRIMARY KEY, name STRING)")
+    db.exec(sql"INSERT INTO nf_test (id, name) VALUES (1, 'hello')")
+    db.exec(sql"INSERT INTO nf_test (id, name) VALUES (2, 'world')")
+
+    let rows = db.getAllRows(sql"SELECT * FROM nf_test")
+    check rows.len == 2
+
+    let row = db.getRow(sql"SELECT * FROM nf_test WHERE id = 1")
+    check row.len == 2
+    check row[0] == "1"
+    check row[1] == "hello"
+
+    let val = db.getValue(sql"SELECT name FROM nf_test WHERE id = 2")
+    check val == "world"
+
+    let cnt = db.getValue(sql"SELECT count(*) FROM nf_test")
+    check cnt == "2"
+
+    db.close()
+
+  test "Adapter parameterized queries":
+    var db = open("127.0.0.1:" & $port, "", "", "default")
+
+    db.exec(sql"CREATE TABLE nf_params (id INT PRIMARY KEY, val STRING)")
+    db.exec(sql"INSERT INTO nf_params (id, val) VALUES (?, ?)", 10, "ten")
+    db.exec(sql"INSERT INTO nf_params (id, val) VALUES (?, ?)", 20, "twenty")
+
+    let row = db.getRow(sql"SELECT val FROM nf_params WHERE id = ?", 10)
+    check row.len >= 1
+    check row[row.len - 1] == "ten"
+
+    db.close()

tests/prop_test.nim

@@ -0,0 +1,123 @@
+## Property-Based Tests — evalExprValue invariants
+import std/unittest
+import std/tables
+import std/random
+import std/os
+import std/monotimes
+import std/math
+
+import barabadb/core/types
+import barabadb/storage/lsm
+import barabadb/query/ir as qir
+import barabadb/query/executor as qexec
+
+suite "Property-Based — evalExprValue Invariants":
+  setup:
+    var testDir = getTempDir() / "baradb_prop_test_" & $getCurrentProcessId() & "_" & $getMonoTime().ticks
+    createDir(testDir)
+    var db = newLSMTree(testDir)
+    var ctx = qexec.newExecutionContext(db)
+
+  teardown:
+    removeDir(testDir)
+
+  proc randIntLit(rng: var Rand, minVal: int = -1000, maxVal: int = 1000): IRExpr =
+    result = IRExpr(kind: irekLiteral, valueKind: vkInt64)
+    result.literal = IRLiteral(kind: vkInt64, int64Val: int64(rng.rand(minVal..maxVal)))
+
+  proc randFloatLit(rng: var Rand, minVal: float = -1000.0, maxVal: float = 1000.0): IRExpr =
+    result = IRExpr(kind: irekLiteral, valueKind: vkFloat64)
+    result.literal = IRLiteral(kind: vkFloat64, float64Val: minVal + rng.rand(maxVal - minVal))
+
+  proc randBinaryExpr(rng: var Rand, left, right: IRExpr, op: IROperator): IRExpr =
+    result = IRExpr(kind: irekBinary)
+    result.binOp = op
+    result.binLeft = left
+    result.binRight = right
+    if left.valueKind == vkInt64 and right.valueKind == vkInt64 and op != irDiv:
+      result.valueKind = vkInt64
+    else:
+      result.valueKind = vkFloat64
+
+  proc randUnaryExpr(rng: var Rand, expr: IRExpr, op: IROperator): IRExpr =
+    result = IRExpr(kind: irekUnary)
+    result.unOp = op
+    result.unExpr = expr
+    result.valueKind = expr.valueKind
+
+  test "Literal eval returns correct ValueKind (INT)":
+    var rng = initRand(42)
+    for i in 0..<100:
+      let lit = randIntLit(rng)
+      let v = evalExprValue(lit, initTable[string, string](), nil)
+      check v.kind == vkInt64
+
+  test "Literal eval returns correct ValueKind (FLOAT)":
+    var rng = initRand(43)
+    for i in 0..<100:
+      let lit = randFloatLit(rng)
+      let v = evalExprValue(lit, initTable[string, string](), nil)
+      check v.kind == vkFloat64
+
+  test "INT addition is commutative":
+    var rng = initRand(44)
+    for i in 0..<100:
+      let a = randIntLit(rng)
+      let b = randIntLit(rng)
+      let sum1 = evalExprValue(randBinaryExpr(rng, a, b, irAdd), initTable[string, string](), nil)
+      let sum2 = evalExprValue(randBinaryExpr(rng, b, a, irAdd), initTable[string, string](), nil)
+      if sum1.kind == vkInt64 and sum2.kind == vkInt64:
+        check sum1.int64Val == sum2.int64Val
+
+  test "FLOAT addition is commutative":
+    var rng = initRand(45)
+    for i in 0..<100:
+      let a = randFloatLit(rng)
+      let b = randFloatLit(rng)
+      let sum1 = evalExprValue(randBinaryExpr(rng, a, b, irAdd), initTable[string, string](), nil)
+      let sum2 = evalExprValue(randBinaryExpr(rng, b, a, irAdd), initTable[string, string](), nil)
+      if sum1.kind == vkFloat64 and sum2.kind == vkFloat64:
+        check abs(sum1.float64Val - sum2.float64Val) < 1e-9
+
+  test "INT multiplication by 1 is identity":
+    var rng = initRand(46)
+    for i in 0..<100:
+      let a = randIntLit(rng)
+      let one = IRExpr(kind: irekLiteral, valueKind: vkInt64)
+      one.literal = IRLiteral(kind: vkInt64, int64Val: 1)
+      let prod = evalExprValue(randBinaryExpr(rng, a, one, irMul), initTable[string, string](), nil)
+      if prod.kind == vkInt64:
+        check prod.int64Val == a.literal.int64Val
+
+  test "Double negation of INT is identity":
+    var rng = initRand(47)
+    for i in 0..<100:
+      let a = randIntLit(rng)
+      let neg = randUnaryExpr(rng, a, irNeg)
+      let negNeg = randUnaryExpr(rng, neg, irNeg)
+      let v = evalExprValue(negNeg, initTable[string, string](), nil)
+      if v.kind == vkInt64:
+        check v.int64Val == a.literal.int64Val
+
+  test "Double negation of FLOAT is identity":
+    var rng = initRand(48)
+    for i in 0..<100:
+      let a = randFloatLit(rng)
+      let neg = randUnaryExpr(rng, a, irNeg)
+      let negNeg = randUnaryExpr(rng, neg, irNeg)
+      let v = evalExprValue(negNeg, initTable[string, string](), nil)
+      if v.kind == vkFloat64:
+        check abs(v.float64Val - a.literal.float64Val) < 1e-9
+
+  test "NULL literal propagates through arithmetic":
+    let nullLit = IRExpr(kind: irekLiteral, valueKind: vkNull)
+    nullLit.literal = IRLiteral(kind: vkNull)
+    let intLit = IRExpr(kind: irekLiteral, valueKind: vkInt64)
+    intLit.literal = IRLiteral(kind: vkInt64, int64Val: 5)
+    for op in [irAdd, irSub, irMul, irDiv]:
+      let expr = IRExpr(kind: irekBinary)
+      expr.binOp = op
+      expr.binLeft = nullLit
+      expr.binRight = intLit
+      let v = evalExprValue(expr, initTable[string, string](), nil)
+      check v.kind == vkNull

tests/test_all.nim

@@ -6,6 +6,7 @@ import std/os
 import std/asyncdispatch
 import std/monotimes
 import std/base64
+import std/random
 
 import barabadb/core/types
 import barabadb/core/mvcc
@@ -3728,3 +3729,5 @@ suite "Join Performance — Hash Join & Index Nested Loop":
     check r.rows[0]["name"] == "Alice"
     check r.rows[3]["name"] == "Carol"
     check r.rows[3]["total"] == "\\N"
+
+