10793540350

Committed 10 Sep 2024 01:31PM UTC coverage: 93.551% (-0.3%) from 93.892%

Build # 10793540350

Build Type

push

github

Committed by

falvaradorodriguez

Commit Message

Fix cowswap test

Run Details

8777 of 9382 relevant lines covered (93.55%)

3.74 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

86.0

/safe_eth/eth/django/forms.py

import binascii
from typing import Any, Optional, Union

from django import forms
from django.core import exceptions
from django.core.exceptions import ValidationError
from django.utils.translation import gettext as _

from hexbytes import HexBytes

from safe_eth.eth.utils import fast_is_checksum_address


class EthereumAddressFieldForm(forms.CharField):
    default_error_messages = {
        "invalid": _("Enter a valid checksummed Ethereum Address."),
    }

    def prepare_value(self, value):
        return value

    def to_python(self, value):
        value = super().to_python(value)
        if value in self.empty_values:
            return None
        elif not fast_is_checksum_address(value):
            raise ValidationError(self.error_messages["invalid"], code="invalid")
        return value


class HexFieldForm(forms.CharField):
    default_error_messages = {
        "invalid": _("Enter a valid hexadecimal."),
    }

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.empty_value = None

    def prepare_value(self, value: memoryview) -> str:
        if value:
            return "0x" + bytes(value).hex()
        else:
            return ""

    def to_python(self, value: Optional[Any]) -> Optional[HexBytes]:
        if value in self.empty_values:
            return self.empty_value
        try:
            if isinstance(value, str):
                value = value.strip()
            if isinstance(value, (str, bytes, bytearray, int)):
                return HexBytes(value)
            else:
                raise TypeError(f"Unsupported type for HexBytes: {type(value)}")
        except (binascii.Error, TypeError, ValueError):
            raise exceptions.ValidationError(
                self.error_messages["invalid"],
                code="invalid",
                params={"value": value},
            )


class Keccak256FieldForm(HexFieldForm):
    default_error_messages = {
        "invalid": _('"%(value)s" is not a valid keccak256 hash.'),
        "length": _('"%(value)s" keccak256 hash should be 32 bytes.'),
    }

    def prepare_value(self, value: Union[str, memoryview]) -> str:
        # Keccak field already returns a hex str
        if isinstance(value, str):
            return value
        return super().prepare_value(value)

    def to_python(self, value: Optional[Any]) -> Optional[HexBytes]:
        python_value: Optional[HexBytes] = super().to_python(value)
        if python_value and len(python_value) != 32:
            raise ValidationError(
                self.error_messages["length"],
                code="length",
                params={"value": python_value.hex()},
            )
        return python_value

1	import binascii	4✔
2	from typing import Any, Optional, Union	4✔
3
4	from django import forms	4✔
5	from django.core import exceptions	4✔
6	from django.core.exceptions import ValidationError	4✔
7	from django.utils.translation import gettext as _	4✔
8
9	from hexbytes import HexBytes	4✔
10
11	from safe_eth.eth.utils import fast_is_checksum_address	4✔
12
13
14	class EthereumAddressFieldForm(forms.CharField):	4✔
15	default_error_messages = {	4✔
16	"invalid": _("Enter a valid checksummed Ethereum Address."),
17	}
18
19	def prepare_value(self, value):	4✔
20	return value	×
21
22	def to_python(self, value):	4✔
23	value = super().to_python(value)	4✔
24	if value in self.empty_values:	4✔
25	return None	×
26	elif not fast_is_checksum_address(value):	4✔
27	raise ValidationError(self.error_messages["invalid"], code="invalid")	4✔
28	return value	4✔
29
30
31	class HexFieldForm(forms.CharField):	4✔
32	default_error_messages = {	4✔
33	"invalid": _("Enter a valid hexadecimal."),
34	}
35
36	def __init__(self, args, *kwargs):	4✔
37	super().__init__(args, *kwargs)	4✔
38	self.empty_value = None	4✔
39
40	def prepare_value(self, value: memoryview) -> str:	4✔
41	if value:	4✔
42	return "0x" + bytes(value).hex()	4✔
43	else:
44	return ""	×
45
46	def to_python(self, value: Optional[Any]) -> Optional[HexBytes]:	4✔
47	if value in self.empty_values:	4✔
48	return self.empty_value	4✔
49	try:	4✔
50	if isinstance(value, str):	4✔
51	value = value.strip()	4✔
52	if isinstance(value, (str, bytes, bytearray, int)):	4✔
53	return HexBytes(value)	4✔
54	else:
55	raise TypeError(f"Unsupported type for HexBytes: {type(value)}")	×
56	except (binascii.Error, TypeError, ValueError):	4✔
57	raise exceptions.ValidationError(	4✔
58	self.error_messages["invalid"],
59	code="invalid",
60	params={"value": value},
61	)
62
63
64	class Keccak256FieldForm(HexFieldForm):	4✔
65	default_error_messages = {	4✔
66	"invalid": _('"%(value)s" is not a valid keccak256 hash.'),
67	"length": _('"%(value)s" keccak256 hash should be 32 bytes.'),
68	}
69
70	def prepare_value(self, value: Union[str, memoryview]) -> str:	4✔
71	# Keccak field already returns a hex str
72	if isinstance(value, str):	×
73	return value	×
74	return super().prepare_value(value)	×
75
76	def to_python(self, value: Optional[Any]) -> Optional[HexBytes]:	4✔
77	python_value: Optional[HexBytes] = super().to_python(value)	4✔
78	if python_value and len(python_value) != 32:	4✔
79	raise ValidationError(	4✔
80	self.error_messages["length"],
81	code="length",
82	params={"value": python_value.hex()},
83	)
84	return python_value	4✔

safe-global / safe-eth-py / 10793540350

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous