verifier_42-contract-lab/test/Verifier.t.sol

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

import "forge-std/Test.sol";
import "../contracts/Verifier.sol";

contract VerifierTest is Test {
    Verifier public verifier;
    address public owner;
    address[] public validators;

    function setUp() public {
        owner = makeAddr("owner");
        vm.startPrank(owner);
        verifier = new Verifier();
        vm.stopPrank();

        // Setup test validators
        validators = new address[](3);
        validators[0] = makeAddr("validator1");
        validators[1] = makeAddr("validator2");
        validators[2] = makeAddr("validator3");
    }

    function test_RequestVerification() public {
        bytes32 contentHash = keccak256("test_content");
        uint256 requiredSignatures = 3;

        vm.prank(address(0x123));
        verifier.requestVerification(contentHash, requiredSignatures, validators);

        (
            address requester,
            bytes32 storedContentHash,
            uint256 timestamp,
            Verifier.VerificationStatus status,
            uint256 storedRequiredSignatures,
        ) = verifier.verificationRequests(contentHash);

        assertEq(requester, address(0x123), "Incorrect requester");
        assertEq(storedContentHash, contentHash, "Incorrect content hash");
        assertEq(status, Verifier.VerificationStatus.Pending, "Incorrect status");
        assertEq(storedRequiredSignatures, requiredSignatures, "Incorrect required signatures");
    }

    function testRevert_RequestVerification_InvalidContentHash() public {
        vm.expectRevert("Invalid content hash");
        verifier.requestVerification(bytes32(0), 3, validators);
    }

    function testRevert_RequestVerification_InvalidSignatureCount() public {
        bytes32 contentHash = keccak256("test_content");
        
        vm.expectRevert("Invalid number of required signatures");
        verifier.requestVerification(contentHash, 2, validators);

        vm.expectRevert("Invalid number of required signatures");
        verifier.requestVerification(contentHash, 11, validators);
    }

    function testRevert_RequestVerification_DuplicateValidators() public {
        bytes32 contentHash = keccak256("test_content");
        address[] memory duplicateValidators = new address[](3);
        duplicateValidators[0] = makeAddr("validator1");
        duplicateValidators[1] = makeAddr("validator1");
        duplicateValidators[2] = makeAddr("validator3");

        vm.expectRevert("Duplicate validators");
        verifier.requestVerification(contentHash, 3, duplicateValidators);
    }

    function test_SignVerification() public {
        bytes32 contentHash = keccak256("test_content");
        uint256 requiredSignatures = 3;

        vm.prank(address(0x123));
        verifier.requestVerification(contentHash, requiredSignatures, validators);

        // Sign from first validator
        vm.prank(validators[0]);
        verifier.signVerification(contentHash, true);

        bool signature = verifier.validatorSignatures(contentHash, validators[0]);
        assertTrue(signature, "First validator signature not recorded");
    }

    function testRevert_SignVerification_NotValidator() public {
        bytes32 contentHash = keccak256("test_content");
        uint256 requiredSignatures = 3;

        vm.prank(address(0x123));
        verifier.requestVerification(contentHash, requiredSignatures, validators);

        vm.expectRevert("Unauthorized validator");
        vm.prank(makeAddr("nonValidator"));
        verifier.signVerification(contentHash, true);
    }

    function testFuzz_RequestVerification(
        address requester, 
        bytes32 contentHash, 
        uint256 sigCount
    ) public {
        vm.assume(contentHash != bytes32(0));
        vm.assume(sigCount >= 3 && sigCount <= 10);

        address[] memory fuzzValidators = new address[](sigCount);
        for (uint i = 0; i < sigCount; i++) {
            fuzzValidators[i] = makeAddr(string(abi.encodePacked("validator", i)));
        }

        vm.prank(requester);
        verifier.requestVerification(contentHash, sigCount, fuzzValidators);
    }

    function test_VerificationCompletion() public {
        bytes32 contentHash = keccak256("test_content");
        uint256 requiredSignatures = 3;

        vm.prank(address(0x123));
        verifier.requestVerification(contentHash, requiredSignatures, validators);

        // Sign from all validators
        for (uint i = 0; i < validators.length; i++) {
            vm.prank(validators[i]);
            verifier.signVerification(contentHash, true);
        }

        (
            ,,,
            Verifier.VerificationStatus status,
            ,
        ) = verifier.verificationRequests(contentHash);

        assertEq(uint256(status), uint256(Verifier.VerificationStatus.Approved), "Verification not completed");
    }
}