add tests

tests/test_core_util.py

@@ -0,0 +1,462 @@
+"""
+Comprehensive unit tests for ``bal.core.util.Util``.
+
+Covers every static method — locktime helpers, amount helpers, comparison
+helpers, UTXO helpers, and migration helpers — with edge cases.
+
+Run:
+    source electrum/env/bin/activate
+    python3 tests/test_core_util.py
+"""
+
+import sys
+import os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), os.pardir))
+
+from bal.core.util import Util
+
+
+def test_locktime_to_str():
+    # timestamp -> ISO format
+    s = Util.locktime_to_str(1700000000)
+    assert "202" in s and "-" in s, f"expected ISO string, got {s!r}"
+
+    # small value -> still treated as timestamp
+    s = Util.locktime_to_str(500000)
+    assert "-" in s and ":" in s, f"expected ISO string, got {s!r}"
+
+    # string input -> unchanged
+    assert Util.locktime_to_str("hello") == "hello"
+
+    # zero -> still treated as timestamp
+    s = Util.locktime_to_str(0)
+    assert "-" in s, f"expected ISO date, got {s!r}"
+
+
+def test_str_to_locktime():
+    # relative suffixes pass through
+    assert Util.str_to_locktime("30d") == "30d"
+    assert Util.str_to_locktime("1y") == "1y"
+
+    # integer string -> int
+    assert isinstance(Util.str_to_locktime("500000"), int)
+    assert Util.str_to_locktime("500000") == 500000
+
+    # ISO date -> int timestamp
+    ts = Util.str_to_locktime("2025-01-01T00:00:00")
+    assert isinstance(ts, int)
+    assert ts > 0
+
+
+def test_parse_locktime_string():
+    # plain int -> same int
+    assert Util.parse_locktime_string(500000) == 500000
+
+    # int as string -> int
+    assert Util.parse_locktime_string("500000") == 500000
+
+    # relative days -> > current timestamp
+    result = Util.parse_locktime_string("7d")
+    import time
+    assert result > time.time() - 86400
+
+    # relative years -> > current timestamp
+    result = Util.parse_locktime_string("1y")
+    assert result > time.time()
+
+    # invalid -> 0
+    assert Util.parse_locktime_string("") == 0
+    assert Util.parse_locktime_string("garbage") == 0
+
+
+def test_int_locktime():
+    assert Util.int_locktime(seconds=1) == 1
+    assert Util.int_locktime(minutes=1) == 60
+    assert Util.int_locktime(hours=1) == 3600
+    assert Util.int_locktime(days=1) == 86400
+    assert Util.int_locktime() == 0
+
+
+def test_encode_decode_amount():
+    dp = 8  # typical BTC decimal point
+
+    # percentage passes through
+    assert Util.encode_amount("50%", dp) == "50%"
+    assert Util.decode_amount("50%", dp) == "50%"
+
+    # satoshi encoding
+    assert Util.encode_amount("1.0", dp) == 100000000
+    assert Util.encode_amount("0.5", dp) == 50000000
+
+    # decoding
+    assert Util.decode_amount(100000000, dp) == "1.00000000"
+    assert Util.decode_amount(50000000, dp) == "0.50000000"
+
+    # edge
+    assert Util.encode_amount("abc", dp) == 0
+    assert Util.decode_amount("abc", dp) == "abc"
+
+
+def test_is_perc():
+    assert Util.is_perc("50%") is True
+    assert Util.is_perc("100%") is True
+    assert Util.is_perc("0%") is True
+    assert Util.is_perc("100") is False
+    assert Util.is_perc(50) is False
+    assert Util.is_perc("") is False
+    assert Util.is_perc(None) is False
+
+
+def test_cmp_array():
+    assert Util.cmp_array([1, 2, 3], [1, 2, 3]) is True
+    assert Util.cmp_array([1, 2, 3], [1, 2]) is False
+    assert Util.cmp_array([], []) is True
+    assert Util.cmp_array([1], [2]) is False
+    assert Util.cmp_array(None, None) is False  # exception path
+
+
+def test_cmp_heir():
+    heira = ["abc", 10000, 12345]
+    heirb = ["abc", 10000, 54321]
+    assert Util.cmp_heir(heira, heirb) is True  # addr(0) + amount(1) match
+
+    heirb2 = ["xyz", 10000, 12345]
+    assert Util.cmp_heir(heira, heirb2) is False  # addr mismatch
+
+    heirb3 = ["abc", 20000, 12345]
+    assert Util.cmp_heir(heira, heirb3) is False  # amount mismatch
+
+
+def test_cmp_willexecutor():
+    a = {"url": "https://we.example", "address": "bc1abc", "base_fee": 1000}
+    b = {"url": "https://we.example", "address": "bc1abc", "base_fee": 1000}
+    assert Util.cmp_willexecutor(a, b) is True
+
+    c = {"url": "https://we.other", "address": "bc1abc", "base_fee": 1000}
+    assert Util.cmp_willexecutor(a, c) is False
+
+    assert Util.cmp_willexecutor(None, None) is True  # None == None
+    assert Util.cmp_willexecutor({}, {}) is True  # both empty
+
+
+def test_search_heir_by_values():
+    heirs = {
+        "alice": {0: "addr1", 1: 1000, 3: 500},
+        "bob": {0: "addr2", 1: 2000, 3: 600},
+    }
+    match = Util.search_heir_by_values(heirs, {0: "addr1", 3: 500}, [0, 3])
+    assert match == "alice"
+
+    no_match = Util.search_heir_by_values(heirs, {0: "addrX", 3: 500}, [0, 3])
+    assert no_match is False
+
+    assert Util.search_heir_by_values({}, {0: "x"}, [0]) is False
+
+
+def test_cmp_heir_by_values():
+    a = {0: "addr1", 1: 1000, 3: 500}
+    b = {0: "addr1", 1: 1000, 3: 500}
+    assert Util.cmp_heir_by_values(a, b, [0, 1]) is True
+    assert Util.cmp_heir_by_values(a, b, [0, 1, 3]) is True
+
+    c = {0: "addr1", 1: 9999, 3: 500}
+    assert Util.cmp_heir_by_values(a, c, [1]) is False
+
+
+def test_cmp_heirs_by_values():
+    a = {"h1": {0: "a1", 1: 100}, "h2": {0: "a2", 1: 200}}
+    b = {"h3": {0: "a1", 1: 100}, "h4": {0: "a2", 1: 200}}
+    assert Util.cmp_heirs_by_values(a, b, [0, 1]) is True
+
+    c = {"h1": {0: "aX", 1: 100}}
+    assert Util.cmp_heirs_by_values(a, c, [0, 1]) is False
+
+
+def test_cmp_inputs():
+    # Without real TxInput objects we test edge cases
+    assert Util.cmp_inputs([], []) is True
+    assert Util.cmp_inputs([1], []) is False
+    assert Util.cmp_inputs([], [1]) is False
+
+
+def test_cmp_outputs():
+    assert Util.cmp_outputs([], []) is True
+    assert Util.cmp_outputs([1], []) is False
+    assert Util.cmp_outputs([], [1]) is False
+
+
+def test_cmp_txs():
+    # No real Transaction objects, but edge coverage
+    class FakeTx:
+        def inputs(self): return []
+        def outputs(self): return []
+    a = FakeTx()
+    assert Util.cmp_txs(a, a) is True
+
+
+def test_get_value_amount():
+    class FakeOutput:
+        def __init__(self, addr, val):
+            self.address = addr
+            self.value = val
+
+    class FakeTx:
+        def outputs(self): return self._outs
+        def __init__(self, outs): self._outs = outs
+
+    # Shared addr+value → both same_amount and same_address → value counted
+    out_a = FakeOutput("bcrt1q087zm5m3jrhfg78zflqefhcr9heh4c98kzmvhp", 1000)
+    out_b = FakeOutput("bcrt1q087zm5m3jrhfg78zflqefhcr9heh4c98kzmvhp", 1000)
+    result = Util.get_value_amount(FakeTx([out_a]), FakeTx([out_b]))
+    assert result == 1000, f"expected 1000, got {result}"
+
+    # Different address, same amount → same_amount only → not counted
+    out_c = FakeOutput("bcrt1q08z5t4x74u2883sx2qwsmzk2hj8e5n7z83e4vy", 1000)
+    result2 = Util.get_value_amount(FakeTx([out_a]), FakeTx([out_c]))
+    assert result2 == 0, f"expected 0, got {result2}"
+
+    # No matching amount → returns False
+    out_d = FakeOutput("bcrt1q08z5t4x74u2883sx2qwsmzk2hj8e5n7z83e4vy", 999)
+    result3 = Util.get_value_amount(FakeTx([out_a]), FakeTx([out_d]))
+    assert result3 is False, f"expected False, got {result3}"
+
+
+def test_chk_locktime():
+    now_ts = 1700000000
+
+    # timestamp locktime still in future
+    assert Util.chk_locktime(now_ts, 1800000000) is True
+
+    # timestamp locktime in past
+    assert Util.chk_locktime(now_ts, 1000000000) is False
+
+    # locktime at boundary
+    assert Util.chk_locktime(now_ts, now_ts) is False
+
+
+def test_anticipate_locktime():
+    ts = 1700000000
+    result = Util.anticipate_locktime(ts, days=1)
+    assert result < ts
+    assert result > 0
+
+    # overflow handling (Windows-safe)
+    huge = 2**32 - 1  # NLOCKTIME_MAX
+    result = Util.anticipate_locktime(huge, days=1)
+    assert result > 0
+
+    # clamp to minimum 1
+    low = Util.anticipate_locktime(10, days=20)
+    assert low >= 1
+
+
+def test_cmp_locktime():
+    assert Util.cmp_locktime("30d", "30d") == 0
+    # Note: cmp_locktime may return nonzero or None for mismatched units
+
+
+def test_get_locktimes():
+    class FakeTx:
+        locktime = 1700000000
+
+    # will with single entry
+    will = {
+        "tx1": {"tx": FakeTx()},
+    }
+    locktimes = list(Util.get_locktimes(will))
+    assert 1700000000 in locktimes
+    assert len(locktimes) == 1
+
+    # empty will
+    assert list(Util.get_locktimes({})) == []
+
+
+def test_get_lowest_locktimes():
+    result = Util.get_lowest_locktimes([500000, 1700000000, 100, 900000])
+    assert isinstance(result, list)
+    assert result == sorted(result)
+    assert 100 in result
+    assert 1700000000 in result
+
+    # empty
+    assert Util.get_lowest_locktimes([]) == []
+
+
+def test_get_will_spent_utxos():
+    class FakeTx:
+        def inputs(self): return [1, 2, 3]
+
+    will = {
+        "tx1": {"tx": FakeTx()},
+        "tx2": {"tx": FakeTx()},
+    }
+    utxos = Util.get_will_spent_utxos(will)
+    assert len(utxos) == 6  # 3 inputs * 2 txs
+
+
+def test_utxo_to_str():
+    class FakeUtxo:
+        def to_str(self): return "txid:0"
+    assert Util.utxo_to_str(FakeUtxo()) == "txid:0"
+
+    class FakePrevout:
+        def to_str(self): return "txid:1"
+    class FakeUtxo2:
+        to_str = None
+        prevout = FakePrevout()
+    assert Util.utxo_to_str(FakeUtxo2()) == "txid:1"
+
+    # fallback
+    class Broken:
+        pass
+    assert len(Util.utxo_to_str(Broken())) > 0
+
+
+def test_cmp_utxo():
+    class A:
+        def to_str(self): return "abc:0"
+    assert Util.cmp_utxo(A(), A()) is True
+
+    class B:
+        def to_str(self): return "xyz:1"
+    assert Util.cmp_utxo(A(), B()) is False
+
+
+def test_in_utxo():
+    class U:
+        def __init__(self, s):
+            self._s = s
+        def to_str(self): return self._s
+
+    utxos = [U("a:0"), U("b:1")]
+    target = U("a:0")
+    assert Util.in_utxo(target, utxos) is True
+    assert Util.in_utxo(U("z:9"), utxos) is False
+    assert Util.in_utxo(target, []) is False
+
+
+def test_cmp_output():
+    class O:
+        def __init__(self, addr, val):
+            self.address = addr
+            self.value = val
+    assert Util.cmp_output(O("a", 100), O("a", 100)) is True
+    assert Util.cmp_output(O("a", 100), O("b", 100)) is False
+    assert Util.cmp_output(O("a", 100), O("a", 200)) is False
+
+
+def test_in_output():
+    class O:
+        def __init__(self, addr, val):
+            self.address = addr
+            self.value = val
+    outputs = [O("a", 100), O("b", 200)]
+    assert Util.in_output(O("a", 100), outputs) is True
+    assert Util.in_output(O("z", 999), outputs) is False
+    assert Util.in_output(O("a", 100), []) is False
+
+
+def test_din_output():
+    class O:
+        def __init__(self, addr, val):
+            self.address = addr
+            self.value = val
+
+    outputs = [O("a", 100), O("b", 200)]
+
+    # same amount AND same address
+    same_amt, same_addr = Util.din_output(O("a", 100), outputs)
+    assert same_amt is True and same_addr is True
+
+    # same amount but different address
+    same_amt, same_addr = Util.din_output(O("c", 100), outputs)
+    assert same_amt is True and same_addr is False
+
+    # different amount
+    same_amt, same_addr = Util.din_output(O("z", 999), outputs)
+    assert same_amt is False and same_addr is False
+
+
+def test_get_current_height():
+    # returns current UNIX timestamp, ignoring network
+    import time
+    now = Util.get_current_height(None)
+    assert abs(now - int(time.time())) < 5
+
+
+def test_copy():
+    d = {"a": 1}
+    Util.copy(d, {"b": 2})
+    assert d == {"a": 1, "b": 2}
+
+    # overwrite
+    Util.copy(d, {"a": 99})
+    assert d["a"] == 99
+
+
+def test_fix_will_settings_tx_fees():
+    settings = {"tx_fees": 50}
+    assert Util.fix_will_settings_tx_fees(settings) is True
+    assert settings["baltx_fees"] == 50
+    assert "tx_fees" not in settings
+
+    # no migration needed
+    assert Util.fix_will_settings_tx_fees({}) is False
+
+
+def test_fix_will_tx_fees():
+    will = {
+        "tx1": {"tx_fees": 30},
+        "tx2": {"baltx_fees": 50},
+    }
+    assert Util.fix_will_tx_fees(will) is True
+    assert will["tx1"]["baltx_fees"] == 30
+    assert "tx_fees" not in will["tx1"]
+
+    # empty will
+    assert Util.fix_will_tx_fees({}) is False
+
+
+def test_text_hex_conversion():
+    assert Util.text_to_hex("BAL") == "42414c"
+    assert Util.hex_to_text("42414c") == "BAL"
+    assert Util.text_to_hex("") == ""
+    assert Util.hex_to_text("") == ""
+    assert Util.hex_to_text("ZZZ") == "Error: Invalid hex string"
+
+
+if __name__ == "__main__":
+    test_locktime_to_str()
+    test_str_to_locktime()
+    test_parse_locktime_string()
+    test_int_locktime()
+    test_encode_decode_amount()
+    test_is_perc()
+    test_cmp_array()
+    test_cmp_heir()
+    test_cmp_willexecutor()
+    test_search_heir_by_values()
+    test_cmp_heir_by_values()
+    test_cmp_heirs_by_values()
+    test_cmp_inputs()
+    test_cmp_outputs()
+    test_cmp_txs()
+    test_get_value_amount()
+    test_chk_locktime()
+    test_anticipate_locktime()
+    test_cmp_locktime()
+    test_get_locktimes()
+    test_get_lowest_locktimes()
+    test_get_will_spent_utxos()
+    test_utxo_to_str()
+    test_cmp_utxo()
+    test_in_utxo()
+    test_cmp_output()
+    test_in_output()
+    test_din_output()
+    test_get_current_height()
+    test_copy()
+    test_fix_will_settings_tx_fees()
+    test_fix_will_tx_fees()
+    test_text_hex_conversion()
+    print(f"[OK] All {sum(1 for k in dir() if k.startswith('test_'))} Util tests passed")