evidence_scout-contract-lab/test/RepositoryHelper.t.sol

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

import "forge-std/Test.sol";
import "../contracts/helpers/RepositoryHelper.sol";
import "../contracts/interfaces/RepositoryInterface.sol";

contract MockRepository is RepositoryInterface {
    address private _owner;
    uint256 private _createdAt;
    uint256 private _lastUpdated;
    bytes32 private _contentHash;
    bool private _isActive;

    constructor(address owner) {
        _owner = owner;
        _createdAt = block.timestamp;
        _isActive = true;
    }

    function getOwner() external view returns (address) {
        return _owner;
    }

    function getCreationTimestamp() external view returns (uint256) {
        return _createdAt;
    }

    function getLastUpdateTimestamp() external view returns (uint256) {
        return _lastUpdated;
    }

    function getContentHash() external view returns (bytes32) {
        return _contentHash;
    }

    function isActive() external view returns (bool) {
        return _isActive;
    }

    function isValidRepository() external pure returns (bool) {
        return true;
    }

    function transferOwnership(address newOwner) external {
        require(msg.sender == _owner, "Not owner");
        _owner = newOwner;
    }

    function updateContentHash(bytes32 newHash) external {
        require(msg.sender == _owner, "Not owner");
        _contentHash = newHash;
        _lastUpdated = block.timestamp;
    }

    function setActive(bool active) external {
        require(msg.sender == _owner, "Not owner");
        _isActive = active;
    }
}

contract RepositoryHelperTest is Test {
    address internal owner;
    address internal newOwner;
    MockRepository internal mockRepository;

    function setUp() public {
        owner = makeAddr("owner");
        newOwner = makeAddr("newOwner");
        vm.prank(owner);
        mockRepository = new MockRepository(owner);
    }

    function test_ValidateRepository() public {
        bool isValid = RepositoryHelper.validateRepository(address(mockRepository));
        assertTrue(isValid, "Repository should be valid");
    }

    function testRevert_ValidateRepository_ZeroAddress() public {
        vm.expectRevert(
            abi.encodeWithSelector(
                RepositoryHelper.InvalidRepositoryAddress.selector, 
                address(0)
            )
        );
        RepositoryHelper.validateRepository(address(0));
    }

    function test_GetRepositoryMetadata() public {
        RepositoryHelper.RepositoryMetadata memory metadata = 
            RepositoryHelper.getRepositoryMetadata(address(mockRepository));
        
        assertEq(metadata.owner, owner, "Owner should match");
        assertTrue(metadata.createdAt > 0, "Creation timestamp should be set");
        assertTrue(metadata.isActive, "Repository should be active");
    }

    function testRevert_GetRepositoryMetadata_InvalidRepository() public {
        address invalidRepo = makeAddr("invalidRepo");
        
        vm.expectRevert(
            abi.encodeWithSelector(
                RepositoryHelper.InvalidRepositoryAddress.selector, 
                invalidRepo
            )
        );
        RepositoryHelper.getRepositoryMetadata(invalidRepo);
    }

    function test_TransferRepositoryOwnership() public {
        vm.prank(owner);
        RepositoryHelper.transferRepositoryOwnership(
            address(mockRepository), 
            owner, 
            newOwner
        );

        RepositoryHelper.RepositoryMetadata memory metadata = 
            RepositoryHelper.getRepositoryMetadata(address(mockRepository));
        
        assertEq(metadata.owner, newOwner, "Owner should be transferred");
    }

    function testRevert_TransferRepositoryOwnership_WrongCaller() public {
        address unauthorized = makeAddr("unauthorized");
        
        vm.prank(unauthorized);
        vm.expectRevert(
            abi.encodeWithSelector(
                RepositoryHelper.InsufficientPermissions.selector, 
                unauthorized
            )
        );
        RepositoryHelper.transferRepositoryOwnership(
            address(mockRepository), 
            owner, 
            newOwner
        );
    }

    function test_UpdateRepositoryContent() public {
        bytes32 newContentHash = keccak256("new content");
        
        vm.prank(owner);
        RepositoryHelper.updateRepositoryContent(
            address(mockRepository), 
            owner, 
            newContentHash
        );

        RepositoryHelper.RepositoryMetadata memory metadata = 
            RepositoryHelper.getRepositoryMetadata(address(mockRepository));
        
        assertEq(metadata.contentHash, newContentHash, "Content hash should be updated");
    }

    function testRevert_UpdateRepositoryContent_Unauthorized() public {
        bytes32 newContentHash = keccak256("new content");
        address unauthorized = makeAddr("unauthorized");
        
        vm.prank(unauthorized);
        vm.expectRevert(