balancer-lite-lua/tests/wg.lua

--[[
  tests/wg.lua — Unit tests for wg.lua

  Pure helpers + injected-exec integration (no root, no wg CLI needed).
]]

package.path = package.path .. ";./src/?.lua"

local wg = require("balancerlite.wg")

local passed = 0
local failed = 0
local function check(name, ok, detail)
  if ok then
    passed = passed + 1
    print("  PASS  " .. name)
  else
    failed = failed + 1
    print("  FAIL  " .. name .. (detail and ("  " .. detail) or ""))
  end
end

-- -----------------------------------------------------------------
-- TEST 1: q() safe-quoting
-- -----------------------------------------------------------------
print("\n[1] q() safe-quoting")
do
  local q = wg.q
  check("plain endpoint",  q("1.2.3.4:51820") == "'1.2.3.4:51820'")
  check("base64 key OK",   q("abcDEF123==")    == "'abcDEF123=='")
  check("slash OK",        q("/dev/null")      == "'/dev/null'")
  check("spaces rejected", q("a b")            == nil)
  check("quote rejected",  q("a'b")            == nil)
  check("nil rejected",    q(nil)              == nil)
end

-- -----------------------------------------------------------------
-- TEST 2: build_set_endpoint_cmd disabled
-- -----------------------------------------------------------------
print("\n[2] build_set_endpoint_cmd disabled")
do
  local r = wg.build_set_endpoint_cmd({enabled=false, interface="wg0",
    public_key="pk", endpoint_a="1.2.3.4:51820"},
    {}, "wan-a")
  check("ok=true (no-op)", r.ok == true)
  check("no cmd", r.cmd == nil)
  check("reason set", type(r.reason) == "string" and r.reason:match("disabled"))
end

-- -----------------------------------------------------------------
-- TEST 3: build_set_endpoint_cmd happy path
-- -----------------------------------------------------------------
print("\n[3] build_set_endpoint_cmd happy path")
do
  local cfg = { enabled=true, interface="wg0",
                public_key="PUBKEY",
                endpoint_a="1.2.3.4:51820",
                endpoint_b="4.5.6.7:51821" }
  local wans = {
    { id="wan-a", address="1.2.3.4/24" },
    { id="wan-b", address="4.5.6.7/24" },
  }
  local r = wg.build_set_endpoint_cmd(cfg, wans, "wan-b")
  check("ok", r.ok, r.err)
  check("cmd present", type(r.cmd) == "string")
  check("cmd contains wg set wg0 peer PUBKEY endpoint '4.5.6.7:51821'",
    r.cmd == "wg set 'wg0' peer 'PUBKEY' endpoint '4.5.6.7:51821'",
    "got: " .. tostring(r.cmd))
end

-- -----------------------------------------------------------------
-- TEST 4: build_set_endpoint_cmd unknown wan
-- -----------------------------------------------------------------
print("\n[4] build_set_endpoint_cmd unknown wan")
do
  local cfg = { enabled=true, interface="wg0", public_key="PUBKEY",
                endpoint_a="1.2.3.4:51820" }
  local r = wg.build_set_endpoint_cmd(cfg, {}, "wan-z")
  check("ok=false", r.ok == false)
  check("err mentions wan-z", type(r.err) == "string" and r.err:match("wan.z"))
end

-- -----------------------------------------------------------------
-- TEST 5: build_set_endpoint_cmd no endpoint for that WAN
-- -----------------------------------------------------------------
print("\n[5] build_set_endpoint_cmd no endpoint configured")
do
  local cfg = { enabled=true, interface="wg0", public_key="PUBKEY",
                endpoint_a="", endpoint_b="4.5.6.7:51821" }
  local r = wg.build_set_endpoint_cmd(cfg, {}, "wan-a")
  check("ok=true (no-op)", r.ok == true)
  check("no cmd", r.cmd == nil)
  check("reason mentions wan-a", type(r.reason) == "string" and r.reason:match("wan.a"))
end

-- -----------------------------------------------------------------
-- TEST 6: build_syncconf_cmd
-- -----------------------------------------------------------------
print("\n[6] build_syncconf_cmd")
do
  local r = wg.build_syncconf_cmd({ enabled=true, interface="wg0" })
  check("ok", r.ok)
  check("cmd", r.cmd == "wg syncconf 'wg0' /dev/null", "got: " .. tostring(r.cmd))

  local r2 = wg.build_syncconf_cmd({ enabled=false })
  check("disabled ok", r2.ok and r2.cmd == nil)
end

-- -----------------------------------------------------------------
-- TEST 7: parse_latest_handshake
-- -----------------------------------------------------------------
print("\n[7] parse_latest_handshake")
do
  local p = wg.parse_latest_handshake
  check("single handshake",
    p("ABC123\t42s ago\n") == 42)
  check("multiple -> min",
    p("A\t100s ago\nB\t5s ago\nC\t60s ago\n") == 5)
  check("nil on empty",   p("") == nil)
  check("nil on garbage", p("no numbers here") == nil)
end

-- -----------------------------------------------------------------
-- TEST 8: set_endpoint with exec injection
-- -----------------------------------------------------------------
print("\n[8] set_endpoint with exec injection")
do
  local cmds = {}
  local function fake_exec(c) cmds[#cmds+1] = c; return 0 end
  local cfg = { enabled=true, interface="wg0",
                public_key="PUBKEY",
                endpoint_a="1.2.3.4:51820",
                endpoint_b="4.5.6.7:51821" }
  local W = wg.new(cfg, {}, { exec = fake_exec })
  local r = W:set_endpoint("wan-a")
  check("ok", r.ok, r.err)
  check("2 cmds run (set + syncconf)", #cmds == 2, "got " .. tostring(#cmds))
  check("first cmd is wg set", cmds[1]:match("^wg set"))
  check("second cmd is wg syncconf", cmds[2]:match("^wg syncconf"))
end

-- -----------------------------------------------------------------
-- TEST 9: set_endpoint disabled (no cmds)
-- -----------------------------------------------------------------
print("\n[9] set_endpoint disabled")
do
  local cmds = {}
  local function fake_exec(c) cmds[#cmds+1] = c; return 0 end
  local W = wg.new({enabled=false, interface="wg0", public_key="PUBKEY"}, {},
                   { exec = fake_exec })
  local r = W:set_endpoint("wan-a")
  check("ok", r.ok)
  check("no cmds", #cmds == 0)
end

-- -----------------------------------------------------------------
-- TEST 10: set_endpoint failure
-- -----------------------------------------------------------------
print("\n[10] set_endpoint exec failure")
do
  local function fake_exec() return 2 end
  local cfg = { enabled=true, interface="wg0", public_key="PUBKEY",
                endpoint_a="1.2.3.4:51820" }
  local W = wg.new(cfg, {}, { exec = fake_exec })
  local r = W:set_endpoint("wan-a")
  check("ok=false", r.ok == false)
  check("err reports rc", type(r.err) == "string" and r.err:match("rc=2"))
end

-- -----------------------------------------------------------------
-- TEST 11: prewarm returns standby endpoint
-- -----------------------------------------------------------------
print("\n[11] prewarm")
do
  local W = wg.new({ enabled=true, prewarm_on_standby=true,
                     endpoint_a="1.2.3.4:51820", endpoint_b="4.5.6.7:51821" }, {})
  check("returns endpoint_a", W:prewarm() == "1.2.3.4:51820")

  local W2 = wg.new({ enabled=true, prewarm_on_standby=false }, {})
  check("disabled returns nil", W2:prewarm() == nil)

  local W3 = wg.new({ enabled=true, prewarm_on_standby=true }, {})
  check("no endpoint returns nil", W3:prewarm() == nil)
end

-- -----------------------------------------------------------------
-- Done
-- -----------------------------------------------------------------
print(string.format("\n=== wg: %d/%d passed ===", passed, passed + failed))
if failed > 0 then os.exit(1) end