smom-dbis-138/test/emoney/unit/DebtRegistryTest.t.sol

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import {Test} from "forge-std/Test.sol";
import {DebtRegistry} from "@emoney/DebtRegistry.sol";
import {IDebtRegistry} from "@emoney/interfaces/IDebtRegistry.sol";
import {ReasonCodes} from "@emoney/libraries/ReasonCodes.sol";
import "@emoney/errors/RegistryErrors.sol";

contract DebtRegistryTest is Test {
    DebtRegistry public registry;
    address public admin;
    address public debtAuthority;
    address public debtor1;
    address public debtor2;

    event LienPlaced(
        uint256 indexed lienId,
        address indexed debtor,
        uint256 amount,
        uint64 expiry,
        uint8 priority,
        address indexed authority,
        bytes32 reasonCode
    );
    event LienReduced(uint256 indexed lienId, uint256 reduceBy, uint256 newAmount);
    event LienReleased(uint256 indexed lienId);

    function setUp() public {
        admin = address(0x1);
        debtAuthority = address(0x2);
        debtor1 = address(0x10);
        debtor2 = address(0x20);

        registry = new DebtRegistry(admin);

        vm.startPrank(admin);
        registry.grantRole(registry.DEBT_AUTHORITY_ROLE(), debtAuthority);
        vm.stopPrank();
    }

    function test_placeLien() public {
        uint256 amount = 1000;
        uint64 expiry = uint64(block.timestamp + 365 days);
        uint8 priority = 1;
        bytes32 reasonCode = ReasonCodes.LIEN_BLOCK;

        vm.expectEmit(true, true, false, true);
        emit LienPlaced(0, debtor1, amount, expiry, priority, debtAuthority, reasonCode);

        vm.prank(debtAuthority);
        uint256 lienId = registry.placeLien(debtor1, amount, expiry, priority, reasonCode);

        assertEq(lienId, 0);
        assertEq(registry.activeLienAmount(debtor1), amount);
        assertTrue(registry.hasActiveLien(debtor1));
        assertEq(registry.activeLienCount(debtor1), 1);

        IDebtRegistry.Lien memory lien = registry.getLien(lienId);
        assertEq(lien.debtor, debtor1);
        assertEq(lien.amount, amount);
        assertEq(lien.expiry, expiry);
        assertEq(lien.priority, priority);
        assertEq(lien.authority, debtAuthority);
        assertEq(lien.reasonCode, reasonCode);
        assertTrue(lien.active);
    }

    function test_placeLien_unauthorized() public {
        vm.expectRevert();
        registry.placeLien(debtor1, 1000, 0, 1, bytes32(0));
    }

    function test_placeLien_zeroDebtor() public {
        vm.prank(debtAuthority);
        vm.expectRevert(abi.encodeWithSelector(DebtZeroDebtor.selector));
        registry.placeLien(address(0), 1000, 0, 1, bytes32(0));
    }

    function test_placeLien_zeroAmount() public {
        vm.prank(debtAuthority);
        vm.expectRevert(abi.encodeWithSelector(DebtZeroAmount.selector));
        registry.placeLien(debtor1, 0, 0, 1, bytes32(0));
    }

    function test_placeMultipleLiens() public {
        vm.prank(debtAuthority);
        registry.placeLien(debtor1, 500, 0, 1, bytes32(0));

        vm.prank(debtAuthority);
        registry.placeLien(debtor1, 300, 0, 2, bytes32(0));

        assertEq(registry.activeLienAmount(debtor1), 800);
        assertEq(registry.activeLienCount(debtor1), 2);
    }

    function test_reduceLien() public {
        vm.prank(debtAuthority);
        uint256 lienId = registry.placeLien(debtor1, 1000, 0, 1, bytes32(0));

        vm.expectEmit(true, false, false, true);
        emit LienReduced(lienId, 300, 700);

        vm.prank(debtAuthority);
        registry.reduceLien(lienId, 300);

        assertEq(registry.activeLienAmount(debtor1), 700);
        assertEq(registry.activeLienCount(debtor1), 1);

        IDebtRegistry.Lien memory lien = registry.getLien(lienId);
        assertEq(lien.amount, 700);
        assertTrue(lien.active);
    }

    function test_reduceLien_full() public {
        vm.prank(debtAuthority);
        uint256 lienId = registry.placeLien(debtor1, 1000, 0, 1, bytes32(0));

        vm.prank(debtAuthority);
        registry.reduceLien(lienId, 1000);

        assertEq(registry.activeLienAmount(debtor1), 0);
        assertEq(registry.activeLienCount(debtor1), 1); // Still counted as active

        IDebtRegistry.Lien memory lien = registry.getLien(lienId);
        assertEq(lien.amount, 0);
        assertTrue(lien.active);
    }

    function test_reduceLien_exceedsAmount() public {
        vm.prank(debtAuthority);
        uint256 lienId = registry.placeLien(debtor1, 1000, 0, 1, bytes32(0));

        vm.prank(debtAuthority);
        vm.expectRevert(abi.encodeWithSelector(DebtReduceByExceedsAmount.selector, lienId, 1001, 1000));
        registry.reduceLien(lienId, 1001);
    }

    function test_reduceLien_inactive() public {
        vm.prank(debtAuthority);
        uint256 lienId = registry.placeLien(debtor1, 1000, 0, 1, bytes32(0));

        vm.prank(debtAuthority);
        registry.releaseLien(lienId);

        vm.prank(debtAuthority);
        vm.expectRevert(abi.encodeWithSelector(DebtLienNotActive.selector, lienId));
        registry.reduceLien(lienId, 100);
    }

    function test_releaseLien() public {
        vm.prank(debtAuthority);
        uint256 lienId = registry.placeLien(debtor1, 1000, 0, 1, bytes32(0));

        vm.expectEmit(true, false, false, true);
        emit LienReleased(lienId);

        vm.prank(debtAuthority);
        registry.releaseLien(lienId);

        assertEq(registry.activeLienAmount(debtor1), 0);
        assertEq(registry.activeLienCount(debtor1), 0);
        assertFalse(registry.hasActiveLien(debtor1));

        IDebtRegistry.Lien memory lien = registry.getLien(lienId);
        assertFalse(lien.active);
    }

    function test_releaseLien_partialReduction() public {
        vm.prank(debtAuthority);
        uint256 lienId = registry.placeLien(debtor1, 1000, 0, 1, bytes32(0));

        vm.prank(debtAuthority);
        registry.reduceLien(lienId, 300);

        vm.prank(debtAuthority);
        registry.releaseLien(lienId);

        assertEq(registry.activeLienAmount(debtor1), 0);
        assertEq(registry.activeLienCount(debtor1), 0);
    }

    function test_expiry_storedButNotEnforced() public {
        uint64 expiry = uint64(block.timestamp + 1 days);

        vm.prank(debtAuthority);
        uint256 lienId = registry.placeLien(debtor1, 1000, expiry, 1, bytes32(0));

        IDebtRegistry.Lien memory lien = registry.getLien(lienId);
        assertEq(lien.expiry, expiry);

        // Expiry is informational - lien remains active even after expiry
        vm.warp(block.timestamp + 2 days);

        assertTrue(registry.hasActiveLien(debtor1));
        assertEq(registry.activeLienAmount(debtor1), 1000);

        // Must explicitly release
        vm.prank(debtAuthority);
        registry.releaseLien(lienId);

        assertFalse(registry.hasActiveLien(debtor1));
    }
}