nomy-data-models 0.33.0

"""Tests for the trade_base module."""

import pytest

from nomy_data_models.models.trade_base import (
    MarketType,
    is_valid_eth_address,
    is_valid_sol_address,
)


@pytest.fixture
def valid_eth_addresses():
    """Fixture providing a list of valid Ethereum addresses for testing."""
    return [
        "0x1234567890123456789012345678901234567890",
        "0xabcdef1234567890abcdef1234567890abcdef12",
        "0xABCDEF1234567890ABCDEF1234567890ABCDEF12",
        "0x0000000000000000000000000000000000000000",
        "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",
    ]


@pytest.fixture
def invalid_eth_addresses():
    """Fixture providing a list of invalid Ethereum addresses for testing."""
    return [
        "",  # Empty string
        "0x",  # Too short
        "0x12345",  # Too short
        "1234567890123456789012345678901234567890",  # Missing 0x prefix
        "0xG1234567890123456789012345678901234567890",  # Invalid character G
        "0x123456789012345678901234567890123456789",  # Too short (39 chars after 0x)
        "0x12345678901234567890123456789012345678901",  # Too long (41 chars after 0x)
        "0x123456789012345678901234567890123456789Z",  # Invalid character Z
    ]


@pytest.fixture
def valid_sol_addresses():
    """Fixture providing a list of valid Solana addresses for testing."""
    return [
        "9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin",
        "3Kk7QaKvyBjQJa8mBbvhzCDQKPu2QzP6vAGvMNpFABQk",
        "7Np41oeYqPefeNQEHSv1UDhYrehxin3NStELsSKCT4K2",
        "JBu1AL4obBcCMqKBBxhpWCNUt136ijcuMZLFvTP7iCbs",
        "SysvarC1ock11111111111111111111111111111111",
    ]


@pytest.fixture
def invalid_sol_addresses():
    """Fixture providing a list of invalid Solana addresses for testing."""
    return [
        "",  # Empty string
        "abc",  # Too short
        "0x1234567890123456789012345678901234567890",  # Ethereum address
        "9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin0",  # Too long
        "9xQeWvG816bUx9EPjHmaT23yvVM2ZW",  # Too short (less than 32 chars)
        "9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFi0",  # Invalid character 0
        "9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFiO",  # Invalid character O
        "9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFiI",  # Invalid character I
    ]


class TestMarketType:
    """Test cases for MarketType enum."""

    def test_market_type_values(self):
        """Test that the MarketType enum has the expected values."""
        assert MarketType.SPOT.value == "spot", "SPOT value should be 'spot'"
        assert MarketType.PERPETUAL.value == "perp", "PERPETUAL value should be 'perp'"

    def test_market_type_comparison(self):
        """Test that the MarketType enum values can be compared."""
        assert MarketType.SPOT == MarketType.SPOT, "SPOT should equal itself"
        assert (
            MarketType.SPOT != MarketType.PERPETUAL
        ), "SPOT should not equal PERPETUAL"
        assert (
            MarketType.PERPETUAL == MarketType.PERPETUAL
        ), "PERPETUAL should equal itself"


class TestEthAddressValidation:
    """Test cases for Ethereum address validation."""

    def test_valid_eth_addresses(self, valid_eth_addresses):
        """Test that valid Ethereum addresses are recognized.

        Args:
            valid_eth_addresses: Fixture providing valid Ethereum addresses
        """
        for address in valid_eth_addresses:
            assert is_valid_eth_address(address), f"Should be valid: {address}"

    def test_invalid_eth_addresses(self, invalid_eth_addresses):
        """Test that invalid Ethereum addresses are rejected.

        Args:
            invalid_eth_addresses: Fixture providing invalid Ethereum addresses
        """
        for address in invalid_eth_addresses:
            assert not is_valid_eth_address(address), f"Should be invalid: {address}"

    def test_non_string_eth_address(self):
        """Test that non-string values are handled properly for ETH addresses."""
        assert not is_valid_eth_address(None), "None should be invalid"
        assert not is_valid_eth_address(123), "Integer should be invalid"
        assert not is_valid_eth_address(True), "Boolean should be invalid"
        assert not is_valid_eth_address([]), "List should be invalid"
        assert not is_valid_eth_address({}), "Dict should be invalid"


class TestSolAddressValidation:
    """Test cases for Solana address validation."""

    def test_valid_sol_addresses(self, valid_sol_addresses):
        """Test that valid Solana addresses are recognized.

        Args:
            valid_sol_addresses: Fixture providing valid Solana addresses
        """
        for address in valid_sol_addresses:
            assert is_valid_sol_address(address), f"Should be valid: {address}"

    def test_invalid_sol_addresses(self, invalid_sol_addresses):
        """Test that invalid Solana addresses are rejected.

        Args:
            invalid_sol_addresses: Fixture providing invalid Solana addresses
        """
        for address in invalid_sol_addresses:
            assert not is_valid_sol_address(address), f"Should be invalid: {address}"

    def test_non_string_sol_address(self):
        """Test that non-string values are handled properly for SOL addresses."""
        assert not is_valid_sol_address(None), "None should be invalid"
        assert not is_valid_sol_address(123), "Integer should be invalid"
        assert not is_valid_sol_address(True), "Boolean should be invalid"
        assert not is_valid_sol_address([]), "List should be invalid"
        assert not is_valid_sol_address({}), "Dict should be invalid"


if __name__ == "__main__":
    pytest.main(["-v", __file__])