diff --git a/docs/userguides/config.md b/docs/userguides/config.md index 919e070e6d..768ae758b7 100644 --- a/docs/userguides/config.md +++ b/docs/userguides/config.md @@ -37,9 +37,58 @@ plugin: This helps keep your secrets out of Ape! +Similarly, any config key-name can also be set with the same named environment variable (with a prefix). + +If a configuration is left unset (i.e., not included in the `ape-config.(yaml|json|toml)` file, Ape will inspect the environment variables as a fallback, following the pattern `APE__SETTING`, where different plugins define different prefixes. + +For example, the following config: + +```yaml +contracts_folder: src/qwe +test: + number_of_accounts: 3 + show_internal: True +compile: + exclude: + - "one" + - "two" + - "three" + include_dependencies: true +``` + +could be entirely defined with environment variables as follows: + +```shell +APE_CONTRACTS_FOLDER=src/contracts +APE_TEST_NUMBER_OF_ACCOUNTS=3 +APE_TEST_SHOW_INTERNAL=true +APE_COMPILE_EXCLUDE='["one", "two", "three"]' +APE_COMPILE_INCLUDE_DEPENDENCIES=true +``` + +Notice the `ape-compile` and `ape-test` plugin include their plugin name `APE_COMPILE` and `APE_TEST` respectively where `contracts_folder` only has the prefix `APE_` since it is not part of a plugin. + +Here is the complete list of supported prefixes that come with Ape out-of-the-box: + +| Module/Plugin | Prefix | +| ------------- | ------------ | +| ape | APE | +| ape_cache | APE_CACHE | +| ape_compile | APE_COMPILE | +| ape_console | APE_CONSOLE | +| ape_ethereum | APE_ETHEREUM | +| ape_networks | APE_NETWORKS | +| ape_node | APE_NODE | +| ape_test | APE_TEST | + +Each plugin outside the core package may define its own prefix, but the standard is `APE_PLUGINNAME_`. + +Using environment variables assists in keeping secrets out of your config files. +However, the primary config should be file-driven and environment variables should only be used when necessary. + ## Base Path -Change the base path if it is different than your project root. +Change the base path if it is different from your project root. For example, imagine a project structure like: ``` diff --git a/pyproject.toml b/pyproject.toml index 2c8e213a9b..11702954e0 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -34,6 +34,7 @@ norecursedirs = "projects" # And 'pytest_ethereum' is not used and causes issues in some environments. addopts = """ -p no:pytest_ethereum +-p no:boa_test """ python_files = "test_*.py" diff --git a/src/ape/api/address.py b/src/ape/api/address.py index 7ab52a81c3..5aa9432e49 100644 --- a/src/ape/api/address.py +++ b/src/ape/api/address.py @@ -150,9 +150,8 @@ def code(self) -> "ContractCode": """ The raw bytes of the smart-contract code at the address. """ - - # TODO: Explore caching this (based on `self.provider.network` and examining code) - return self.provider.get_code(self.address) + # NOTE: Chain manager handles code caching. + return self.chain_manager.get_code(self.address) @property def codesize(self) -> int: diff --git a/src/ape/api/config.py b/src/ape/api/config.py index 141b226d02..7ae7640140 100644 --- a/src/ape/api/config.py +++ b/src/ape/api/config.py @@ -66,7 +66,7 @@ class PluginConfig(BaseSettings): a config API must register a subclass of this class. """ - model_config = SettingsConfigDict(extra="allow") + model_config = SettingsConfigDict(extra="allow", env_prefix="APE_") @classmethod def from_overrides( @@ -285,7 +285,7 @@ class ApeConfig(ExtraAttributesMixin, BaseSettings, ManagerAccessMixin): def __init__(self, *args, **kwargs): project_path = kwargs.get("project") - super(BaseSettings, self).__init__(*args, **kwargs) + super().__init__(*args, **kwargs) # NOTE: Cannot reference `self` at all until after super init. self._project_path = project_path @@ -350,7 +350,7 @@ def __init__(self, *args, **kwargs): """ # NOTE: Plugin configs are technically "extras". - model_config = SettingsConfigDict(extra="allow") + model_config = SettingsConfigDict(extra="allow", env_prefix="APE_") @model_validator(mode="before") @classmethod diff --git a/src/ape/managers/_contractscache.py b/src/ape/managers/_contractscache.py index fe5677bc3e..d83a484250 100644 --- a/src/ape/managers/_contractscache.py +++ b/src/ape/managers/_contractscache.py @@ -270,13 +270,22 @@ def _delete_proxy(self, address: AddressType): def __contains__(self, address: AddressType) -> bool: return self.get(address) is not None - def cache_deployment(self, contract_instance: ContractInstance): + def cache_deployment( + self, + contract_instance: ContractInstance, + proxy_info: Optional[ProxyInfoAPI] = None, + detect_proxy: bool = True, + ): """ Cache the given contract instance's type and deployment information. Args: contract_instance (:class:`~ape.contracts.base.ContractInstance`): The contract to cache. + proxy_info (Optional[ProxyInfoAPI]): Pass in the proxy info, if it is known, to + avoid the potentially expensive look-up. + detect_proxy (bool): Set to ``False`` to avoid detecting if the contract is a + proxy. """ address = contract_instance.address contract_type = contract_instance.contract_type # may be a proxy @@ -285,24 +294,22 @@ def cache_deployment(self, contract_instance: ContractInstance): # in case it is needed somewhere. It may get overridden. self.contract_types.memory[address] = contract_type - if proxy_info := self.provider.network.ecosystem.get_proxy_info(address): - # The user is caching a deployment of a proxy with the target already set. - self.cache_proxy_info(address, proxy_info) - if implementation_contract := self.get(proxy_info.target): - updated_proxy_contract = _get_combined_contract_type( - contract_type, proxy_info, implementation_contract - ) - self.contract_types[address] = updated_proxy_contract + if proxy_info: + # Was given proxy info. + self._cache_proxy_contract(address, proxy_info, contract_type, contract_instance) - # Use this contract type in the user's contract instance. - contract_instance.contract_type = updated_proxy_contract + elif detect_proxy: + # Proxy info was not provided. Use the connected ecosystem to figure it out. + if proxy_info := self.provider.network.ecosystem.get_proxy_info(address): + # The user is caching a deployment of a proxy with the target already set. + self._cache_proxy_contract(address, proxy_info, contract_type, contract_instance) else: - # No implementation yet. Just cache proxy. + # Cache as normal. self.contract_types[address] = contract_type else: - # Regular contract. Cache normally. + # Cache as normal; do not do expensive proxy detection. self.contract_types[address] = contract_type # Cache the deployment now. @@ -312,6 +319,26 @@ def cache_deployment(self, contract_instance: ContractInstance): return contract_type + def _cache_proxy_contract( + self, + address: AddressType, + proxy_info: ProxyInfoAPI, + contract_type: ContractType, + contract_instance: ContractInstance, + ): + self.cache_proxy_info(address, proxy_info) + if implementation_contract := self.get(proxy_info.target): + updated_proxy_contract = _get_combined_contract_type( + contract_type, proxy_info, implementation_contract + ) + self.contract_types[address] = updated_proxy_contract + + # Use this contract type in the user's contract instance. + contract_instance.contract_type = updated_proxy_contract + else: + # No implementation yet. Just cache proxy. + self.contract_types[address] = contract_type + def cache_proxy_info(self, address: AddressType, proxy_info: ProxyInfoAPI): """ Cache proxy info for a particular address, useful for plugins adding already @@ -492,6 +519,8 @@ def get( address: AddressType, default: Optional[ContractType] = None, fetch_from_explorer: bool = True, + proxy_info: Optional[ProxyInfoAPI] = None, + detect_proxy: bool = True, ) -> Optional[ContractType]: """ Get a contract type by address. @@ -506,6 +535,9 @@ def get( fetch_from_explorer (bool): Set to ``False`` to avoid fetching from an explorer. Defaults to ``True``. Only fetches if it needs to (uses disk & memory caching otherwise). + proxy_info (Optional[ProxyInfoAPI]): Pass in the proxy info, if it is known, + to avoid the potentially expensive look-up. + detect_proxy (bool): Set to ``False`` to avoid detecting if it is a proxy. Returns: Optional[ContractType]: The contract type if it was able to get one, @@ -531,13 +563,14 @@ def get( else: # Contract is not cached yet. Check broader sources, such as an explorer. - # First, detect if this is a proxy. - if not (proxy_info := self.proxy_infos[address_key]): - if proxy_info := self.provider.network.ecosystem.get_proxy_info(address_key): - self.proxy_infos[address_key] = proxy_info + if not proxy_info and detect_proxy: + # Proxy info not provided. Attempt to detect. + if not (proxy_info := self.proxy_infos[address_key]): + if proxy_info := self.provider.network.ecosystem.get_proxy_info(address_key): + self.proxy_infos[address_key] = proxy_info if proxy_info: - # Contract is a proxy. + # Contract is a proxy (either was detected or provided). implementation_contract_type = self.get(proxy_info.target, default=default) proxy_contract_type = ( self._get_contract_type_from_explorer(address_key) @@ -554,12 +587,6 @@ def get( self.contract_types[address_key] = contract_type_to_cache return contract_type_to_cache - if not self.provider.get_code(address_key): - if default: - self.contract_types[address_key] = default - - return default - # Also gets cached to disk for faster lookup next time. if fetch_from_explorer: contract_type = self._get_contract_type_from_explorer(address_key) @@ -594,6 +621,8 @@ def instance_at( txn_hash: Optional[Union[str, "HexBytes"]] = None, abi: Optional[Union[list[ABI], dict, str, Path]] = None, fetch_from_explorer: bool = True, + proxy_info: Optional[ProxyInfoAPI] = None, + detect_proxy: bool = True, ) -> ContractInstance: """ Get a contract at the given address. If the contract type of the contract is known, @@ -618,6 +647,9 @@ def instance_at( fetch_from_explorer (bool): Set to ``False`` to avoid fetching from the explorer. Defaults to ``True``. Won't fetch unless it needs to (uses disk & memory caching first). + proxy_info (Optional[ProxyInfoAPI]): Pass in the proxy info, if it is known, to avoid + the potentially expensive look-up. + detect_proxy (bool): Set to ``False`` to avoid detecting if the contract is a proxy. Returns: :class:`~ape.contracts.base.ContractInstance` @@ -640,7 +672,11 @@ def instance_at( try: # Always attempt to get an existing contract type to update caches contract_type = self.get( - contract_address, default=contract_type, fetch_from_explorer=fetch_from_explorer + contract_address, + default=contract_type, + fetch_from_explorer=fetch_from_explorer, + proxy_info=proxy_info, + detect_proxy=detect_proxy, ) except Exception as err: if contract_type or abi: diff --git a/src/ape/managers/chain.py b/src/ape/managers/chain.py index 475f00577f..c4e640554e 100644 --- a/src/ape/managers/chain.py +++ b/src/ape/managers/chain.py @@ -37,8 +37,7 @@ if TYPE_CHECKING: from rich.console import Console as RichConsole - from ape.types.trace import GasReport, SourceTraceback - from ape.types.vm import SnapshotID + from ape.types import BlockID, ContractCode, GasReport, SnapshotID, SourceTraceback class BlockContainer(BaseManager): @@ -703,7 +702,7 @@ def _get_console(self, *args, **kwargs): class ChainManager(BaseManager): """ A class for managing the state of the active blockchain. - Also handy for querying data about the chain and managing local caches. + Also, handy for querying data about the chain and managing local caches. Access the chain manager singleton from the root ``ape`` namespace. Usage example:: @@ -716,6 +715,7 @@ class ChainManager(BaseManager): _block_container_map: dict[int, BlockContainer] = {} _transaction_history_map: dict[int, TransactionHistory] = {} _reports: ReportManager = ReportManager() + _code: dict[str, dict[str, dict[AddressType, "ContractCode"]]] = {} @cached_property def contracts(self) -> ContractCache: @@ -965,3 +965,26 @@ def get_receipt(self, transaction_hash: str) -> ReceiptAPI: raise TransactionNotFoundError(transaction_hash=transaction_hash) return receipt + + def get_code( + self, address: AddressType, block_id: Optional["BlockID"] = None + ) -> "ContractCode": + network = self.provider.network + + # Two reasons to avoid caching: + # 1. dev networks - chain isolation makes this mess up + # 2. specifying block_id= kwarg - likely checking if code + # exists at the time and shouldn't use cache. + skip_cache = network.is_dev or block_id is not None + if skip_cache: + return self.provider.get_code(address, block_id=block_id) + + self._code.setdefault(network.ecosystem.name, {}) + self._code[network.ecosystem.name].setdefault(network.name, {}) + if address in self._code[network.ecosystem.name][network.name]: + return self._code[network.ecosystem.name][network.name][address] + + # Get from RPC for the first time AND use cache. + code = self.provider.get_code(address) + self._code[network.ecosystem.name][network.name][address] = code + return code diff --git a/src/ape_cache/config.py b/src/ape_cache/config.py index 264516b738..dc45f7f1a3 100644 --- a/src/ape_cache/config.py +++ b/src/ape_cache/config.py @@ -1,5 +1,8 @@ +from pydantic_settings import SettingsConfigDict + from ape.api.config import PluginConfig class CacheConfig(PluginConfig): size: int = 1024**3 # 1gb + model_config = SettingsConfigDict(extra="allow", env_prefix="APE_CACHE_") diff --git a/src/ape_compile/config.py b/src/ape_compile/config.py index 012e590b04..ef0c749f5f 100644 --- a/src/ape_compile/config.py +++ b/src/ape_compile/config.py @@ -3,6 +3,7 @@ from typing import Union from pydantic import field_serializer, field_validator +from pydantic_settings import SettingsConfigDict from ape.api.config import ConfigEnum, PluginConfig from ape.utils.misc import SOURCE_EXCLUDE_PATTERNS @@ -53,6 +54,8 @@ class Config(PluginConfig): Extra selections to output. Outputs to ``.build/{key.lower()}``. """ + model_config = SettingsConfigDict(extra="allow", env_prefix="APE_COMPILE_") + @field_validator("exclude", mode="before") @classmethod def validate_exclude(cls, value): diff --git a/src/ape_console/config.py b/src/ape_console/config.py index 48b432ced2..9066867714 100644 --- a/src/ape_console/config.py +++ b/src/ape_console/config.py @@ -1,6 +1,10 @@ +from pydantic_settings import SettingsConfigDict + from ape.api.config import PluginConfig class ConsoleConfig(PluginConfig): plugins: list[str] = [] """Additional IPython plugins to include in your session.""" + + model_config = SettingsConfigDict(extra="allow", env_prefix="APE_CONSOLE_") diff --git a/src/ape_ethereum/ecosystem.py b/src/ape_ethereum/ecosystem.py index 94aff193be..61efac483a 100644 --- a/src/ape_ethereum/ecosystem.py +++ b/src/ape_ethereum/ecosystem.py @@ -157,6 +157,8 @@ class NetworkConfig(PluginConfig): request_headers: dict = {} """Optionally config extra request headers whenever using this network.""" + model_config = SettingsConfigDict(extra="allow", env_prefix="APE_ETHEREUM_") + @field_validator("gas_limit", mode="before") @classmethod def validate_gas_limit(cls, value): @@ -233,7 +235,7 @@ class BaseEthereumConfig(PluginConfig): # NOTE: This gets appended to Ape's root User-Agent string. request_headers: dict = {} - model_config = SettingsConfigDict(extra="allow") + model_config = SettingsConfigDict(extra="allow", env_prefix="APE_ETHEREUM_") @model_validator(mode="before") @classmethod @@ -458,7 +460,7 @@ def encode_contract_blueprint( ) def get_proxy_info(self, address: AddressType) -> Optional[ProxyInfo]: - contract_code = self.provider.get_code(address) + contract_code = self.chain_manager.get_code(address) if isinstance(contract_code, bytes): contract_code = to_hex(contract_code) @@ -1150,12 +1152,15 @@ def _enrich_calltree(self, call: dict, **kwargs) -> dict: except KeyError: name = call["method_id"] else: - assert isinstance(method_abi, MethodABI) # For mypy - - # Check if method name duplicated. If that is the case, use selector. - times = len([x for x in contract_type.methods if x.name == method_abi.name]) - name = (method_abi.name if times == 1 else method_abi.selector) or call["method_id"] - call = self._enrich_calldata(call, method_abi, **kwargs) + if isinstance(method_abi, MethodABI): + # Check if method name duplicated. If that is the case, use selector. + times = len([x for x in contract_type.methods if x.name == method_abi.name]) + name = (method_abi.name if times == 1 else method_abi.selector) or call[ + "method_id" + ] + call = self._enrich_calldata(call, method_abi, **kwargs) + else: + name = call.get("method_id") or "0x" else: name = call.get("method_id") or "0x" diff --git a/src/ape_ethereum/query.py b/src/ape_ethereum/query.py index 0cece4e740..7dd8a4f9ca 100644 --- a/src/ape_ethereum/query.py +++ b/src/ape_ethereum/query.py @@ -39,7 +39,7 @@ def perform_contract_creation_query( Find when a contract was deployed using binary search and block tracing. """ # skip the search if there is still no code at address at head - if not self.provider.get_code(query.contract): + if not self.chain_manager.get_code(query.contract): return None def find_creation_block(lo, hi): @@ -47,13 +47,13 @@ def find_creation_block(lo, hi): # takes log2(height), doesn't work with contracts that have been reinit. while hi - lo > 1: mid = (lo + hi) // 2 - code = self.provider.get_code(query.contract, block_id=mid) + code = self.chain_manager.get_code(query.contract, block_id=mid) if not code: lo = mid else: hi = mid - if self.provider.get_code(query.contract, block_id=hi): + if self.chain_manager.get_code(query.contract, block_id=hi): return hi return None diff --git a/src/ape_networks/config.py b/src/ape_networks/config.py index 381cd268b2..a519ed64fe 100644 --- a/src/ape_networks/config.py +++ b/src/ape_networks/config.py @@ -1,5 +1,7 @@ from typing import Optional +from pydantic_settings import SettingsConfigDict + from ape.api.config import PluginConfig @@ -26,6 +28,8 @@ class CustomNetwork(PluginConfig): request_header: dict = {} """The HTTP request header.""" + model_config = SettingsConfigDict(extra="allow", env_prefix="APE_NETWORKS_") + @property def is_fork(self) -> bool: """ @@ -36,3 +40,4 @@ def is_fork(self) -> bool: class NetworksConfig(PluginConfig): custom: list[CustomNetwork] = [] + model_config = SettingsConfigDict(extra="allow", env_prefix="APE_NETWORKS_") diff --git a/src/ape_node/provider.py b/src/ape_node/provider.py index f8af5eeb08..579306de8f 100644 --- a/src/ape_node/provider.py +++ b/src/ape_node/provider.py @@ -297,7 +297,7 @@ class EthereumNetworkConfig(PluginConfig): # Make sure to run via `geth --dev` (or similar) local: dict = {**DEFAULT_SETTINGS.copy(), "chain_id": DEFAULT_TEST_CHAIN_ID} - model_config = SettingsConfigDict(extra="allow") + model_config = SettingsConfigDict(extra="allow", env_prefix="APE_NODE_") @field_validator("local", mode="before") @classmethod @@ -357,7 +357,7 @@ class EthereumNodeConfig(PluginConfig): Optionally specify request headers to use whenever using this provider. """ - model_config = SettingsConfigDict(extra="allow") + model_config = SettingsConfigDict(extra="allow", env_prefix="APE_NODE_") @field_validator("call_trace_approach", mode="before") @classmethod diff --git a/src/ape_test/accounts.py b/src/ape_test/accounts.py index d14f09fcbd..6f41dbe615 100644 --- a/src/ape_test/accounts.py +++ b/src/ape_test/accounts.py @@ -82,7 +82,12 @@ def generate_account(self, index: Optional[int] = None) -> "TestAccountAPI": account = self.init_test_account( new_index, generated_account.address, generated_account.private_key ) - self.generated_accounts.append(account) + + # Only cache if being created outside the expected number of accounts. + # Else, ends up cached twice and caused logic problems elsewhere. + if new_index >= self.number_of_accounts: + self.generated_accounts.append(account) + return account @classmethod diff --git a/src/ape_test/config.py b/src/ape_test/config.py index 3ce2609dfe..adb2541a6f 100644 --- a/src/ape_test/config.py +++ b/src/ape_test/config.py @@ -1,6 +1,7 @@ from typing import TYPE_CHECKING, NewType, Optional, Union from pydantic import NonNegativeInt, field_validator +from pydantic_settings import SettingsConfigDict from ape.api.config import PluginConfig from ape.utils.basemodel import ManagerAccessMixin @@ -19,11 +20,13 @@ class EthTesterProviderConfig(PluginConfig): chain_id: int = DEFAULT_TEST_CHAIN_ID auto_mine: bool = True + model_config = SettingsConfigDict(extra="allow", env_prefix="APE_TEST_") class GasExclusion(PluginConfig): contract_name: str = "*" # If only given method, searches across all contracts. method_name: Optional[str] = None # By default, match all methods in a contract + model_config = SettingsConfigDict(extra="allow", env_prefix="APE_TEST_") CoverageExclusion = NewType("CoverageExclusion", GasExclusion) @@ -48,6 +51,8 @@ class GasConfig(PluginConfig): Report-types to use. Currently, only supports `terminal`. """ + model_config = SettingsConfigDict(extra="allow", env_prefix="APE_TEST_") + @field_validator("reports", mode="before") @classmethod def validate_reports(cls, values): @@ -89,6 +94,8 @@ class CoverageReportsConfig(PluginConfig): Set to ``True`` to generate HTML coverage reports. """ + model_config = SettingsConfigDict(extra="allow", env_prefix="APE_TEST_") + @property def has_any(self) -> bool: return any(x not in ({}, None, False) for x in (self.html, self.terminal, self.xml)) @@ -119,6 +126,8 @@ class CoverageConfig(PluginConfig): use ``prefix_*`` to skip all items with a certain prefix. """ + model_config = SettingsConfigDict(extra="allow", env_prefix="APE_TEST_") + class IsolationConfig(PluginConfig): enable_session: bool = True @@ -146,6 +155,8 @@ class IsolationConfig(PluginConfig): Set to ``False`` to disable function isolation. """ + model_config = SettingsConfigDict(extra="allow", env_prefix="APE_TEST_") + def get_isolation(self, scope: "Scope") -> bool: return getattr(self, f"enable_{scope.name.lower()}") @@ -209,6 +220,8 @@ class ApeTestConfig(PluginConfig): ``False`` to disable all and ``True`` (default) to disable all. """ + model_config = SettingsConfigDict(extra="allow", env_prefix="APE_TEST_") + @field_validator("balance", mode="before") @classmethod def validate_balance(cls, value): diff --git a/tests/functional/conftest.py b/tests/functional/conftest.py index 85c013a710..20f1557459 100644 --- a/tests/functional/conftest.py +++ b/tests/functional/conftest.py @@ -691,7 +691,7 @@ def create_mock_sepolia(ethereum, eth_tester_provider, vyper_contract_instance): @contextmanager def fn(): # Ensuring contract exists before hack. - # This allow the network to be past genesis which is more realistic. + # This allows the network to be past genesis which is more realistic. _ = vyper_contract_instance eth_tester_provider.network.name = "sepolia" yield eth_tester_provider.network diff --git a/tests/functional/geth/test_chain.py b/tests/functional/geth/test_chain.py new file mode 100644 index 0000000000..09bd82ab41 --- /dev/null +++ b/tests/functional/geth/test_chain.py @@ -0,0 +1,18 @@ +from tests.conftest import geth_process_test + + +@geth_process_test +def test_get_code(mocker, chain, geth_contract, mock_sepolia): + # NOTE: Using mock_sepolia because code doesn't get cached in local networks. + actual = chain.get_code(geth_contract.address) + expected = chain.provider.get_code(geth_contract.address) + assert actual == expected + + # Ensure uses cache (via not using provider). + provider_spy = mocker.spy(chain.provider.web3.eth, "get_code") + _ = chain.get_code(geth_contract.address) + assert provider_spy.call_count == 0 + + # block_id test, cache should interfere. + actual_2 = chain.get_code(geth_contract.address, block_id=0) + assert not actual_2 # Doesn't exist at block 0. diff --git a/tests/functional/geth/test_contracts_cache.py b/tests/functional/geth/test_contracts_cache.py index 92782c49fa..f95ddc0f3e 100644 --- a/tests/functional/geth/test_contracts_cache.py +++ b/tests/functional/geth/test_contracts_cache.py @@ -39,7 +39,7 @@ def get_contract_type(address, *args, **kwargs): raise ValueError("Fake explorer only knows about proxy and target contracts.") with create_mock_sepolia() as network: - # Setup our network to use our fake explorer. + # Set up our network to use our fake explorer. mock_explorer.get_contract_type.side_effect = get_contract_type network.__dict__["explorer"] = mock_explorer diff --git a/tests/functional/test_config.py b/tests/functional/test_config.py index 6d82b36598..2c31d22381 100644 --- a/tests/functional/test_config.py +++ b/tests/functional/test_config.py @@ -1,7 +1,7 @@ import os import re from pathlib import Path -from typing import TYPE_CHECKING, Optional, Union +from typing import TYPE_CHECKING, Any, Callable, Optional, Union import pytest from pydantic import ValidationError @@ -11,8 +11,12 @@ from ape.exceptions import ConfigError from ape.managers.config import CONFIG_FILE_NAME, merge_configs from ape.utils.os import create_tempdir -from ape_ethereum.ecosystem import EthereumConfig, NetworkConfig -from ape_networks import CustomNetwork +from ape_cache.config import CacheConfig +from ape_compile.config import Config as CompileConfig +from ape_ethereum.ecosystem import EthereumConfig, ForkedNetworkConfig, NetworkConfig +from ape_networks.config import CustomNetwork +from ape_node.provider import EthereumNetworkConfig, EthereumNodeConfig +from ape_test.config import CoverageReportsConfig, GasConfig, GasExclusion from tests.functional.conftest import PROJECT_WITH_LONG_CONTRACTS_FOLDER if TYPE_CHECKING: @@ -129,6 +133,73 @@ def test_model_validate_path_contracts_folder(): assert cfg.contracts_folder == str(path) +def test_model_validate_handles_environment_variables(): + def run_test(cls: Callable, attr: str, name: str, value: str, expected: Any = None): + expected = expected if expected is not None else value + before: str | None = os.environ.get(name) + os.environ[name] = value + try: + instance = cls() + assert getattr(instance, attr) == expected + finally: + if before is not None: + os.environ[name] = before + else: + os.environ.pop(name, None) + + # Test different config classes. + run_test(ApeConfig, "contracts_folder", "APE_CONTRACTS_FOLDER", "3465220869b2") + run_test(CacheConfig, "size", "APE_CACHE_SIZE", "8627", 8627) + run_test( + CompileConfig, "include_dependencies", "APE_COMPILE_INCLUDE_DEPENDENCIES", "true", True + ) + run_test( + ForkedNetworkConfig, "upstream_provider", "APE_ETHEREUM_UPSTREAM_PROVIDER", "411236f13659" + ) + run_test( + NetworkConfig, "required_confirmations", "APE_ETHEREUM_REQUIRED_CONFIRMATIONS", "6498", 6498 + ) + run_test(EthereumNetworkConfig, "mainnet", "APE_NODE_MAINNET", '{"a":"b"}', {"a": "b"}) + run_test(EthereumNodeConfig, "executable", "APE_NODE_EXECUTABLE", "40613177e494") + run_test(CoverageReportsConfig, "terminal", "APE_TEST_TERMINAL", "false", False) + run_test(GasConfig, "reports", "APE_TEST_REPORTS", '["terminal"]', ["terminal"]) + run_test(GasExclusion, "method_name", "APE_TEST_METHOD_NAME", "32aa54e3c5d2") + + # Assert that union types are handled. + run_test(NetworkConfig, "gas_limit", "APE_ETHEREUM_GAS_LIMIT", "0", 0) + run_test(NetworkConfig, "gas_limit", "APE_ETHEREUM_GAS_LIMIT", "0x100", 0x100) + run_test(NetworkConfig, "gas_limit", "APE_ETHEREUM_GAS_LIMIT", "auto") + run_test(NetworkConfig, "gas_limit", "APE_ETHEREUM_GAS_LIMIT", "max") + with pytest.raises(ValidationError, match=r"Value error, Invalid gas limit"): + run_test(NetworkConfig, "gas_limit", "APE_ETHEREUM_GAS_LIMIT", "something") + + # Assert that various bool variants are parsed correctly. + for bool_val in ("0", "False", "fALSE", "FALSE"): + run_test(NetworkConfig, "is_mainnet", "APE_ETHEREUM_IS_MAINNET", bool_val, False) + + for bool_val in ("1", "True", "tRUE", "TRUE"): + run_test(NetworkConfig, "is_mainnet", "APE_ETHEREUM_IS_MAINNET", bool_val, True) + + # We expect a failure when there's a type mismatch. + with pytest.raises( + ValidationError, + match=r"Input should be a valid boolean, unable to interpret input", + ): + run_test(NetworkConfig, "is_mainnet", "APE_ETHEREUM_IS_MAINNET", "not a boolean", False) + + with pytest.raises( + ValidationError, + match=r"Input should be a valid integer, unable to parse string as an integer", + ): + run_test( + NetworkConfig, + "required_confirmations", + "APE_ETHEREUM_REQUIRED_CONFIRMATIONS", + "not a number", + 42, + ) + + @pytest.mark.parametrize( "file", ("ape-config.yml", "ape-config.yaml", "ape-config.json", "pyproject.toml") ) @@ -152,7 +223,7 @@ def test_validate_file(file): assert "Excl*.json" in actual.compile.exclude -def test_validate_file_expands_env_vars(): +def test_validate_file_expands_environment_variables(): secret = "mycontractssecretfolder" env_var_name = "APE_TEST_CONFIG_SECRET_CONTRACTS_FOLDER" os.environ[env_var_name] = secret diff --git a/tests/functional/test_contracts_cache.py b/tests/functional/test_contracts_cache.py index 3b1c01a4a7..0342080322 100644 --- a/tests/functional/test_contracts_cache.py +++ b/tests/functional/test_contracts_cache.py @@ -120,6 +120,45 @@ def test_instance_at_use_abi(chain, solidity_fallback_contract, owner): assert instance2.contract_type.abi == instance.contract_type.abi +def test_instance_at_provide_proxy(mocker, chain, vyper_contract_instance, owner): + address = vyper_contract_instance.address + container = _make_minimal_proxy(address=address.lower()) + proxy = container.deploy(sender=owner) + proxy_info = chain.contracts.proxy_infos[proxy.address] + + del chain.contracts[proxy.address] + + proxy_detection_spy = mocker.spy(chain.contracts.proxy_infos, "get_type") + + with pytest.raises(ContractNotFoundError): + # This just fails because we deleted it from the cache so Ape no + # longer knows what the contract type is. That is fine for this test! + chain.contracts.instance_at(proxy.address, proxy_info=proxy_info) + + # The real test: we check the spy to ensure we never attempted to look up + # the proxy info for the given address to `instance_at()`. + for call in proxy_detection_spy.call_args_list: + for arg in call[0]: + assert proxy.address != arg + + +def test_instance_at_skip_proxy(mocker, chain, vyper_contract_instance, owner): + address = vyper_contract_instance.address + del chain.contracts[address] + proxy_detection_spy = mocker.spy(chain.contracts.proxy_infos, "get_type") + + with pytest.raises(ContractNotFoundError): + # This just fails because we deleted it from the cache so Ape no + # longer knows what the contract type is. That is fine for this test! + chain.contracts.instance_at(address, detect_proxy=False) + + # The real test: we check the spy to ensure we never attempted to look up + # the proxy info for the given address to `instance_at()`. + for call in proxy_detection_spy.call_args_list: + for arg in call[0]: + assert address != arg + + def test_cache_deployment_live_network( chain, vyper_contract_instance, diff --git a/tests/functional/test_coverage.py b/tests/functional/test_coverage.py index ce9ae2a35d..63aa237b26 100644 --- a/tests/functional/test_coverage.py +++ b/tests/functional/test_coverage.py @@ -255,7 +255,7 @@ def init_profile(source_cov, src): try: # Hack in our mock compiler. - _ = compilers.registered_compilers # Ensure cache is exists. + _ = compilers.registered_compilers # Ensure cache exists. compilers.__dict__["registered_compilers"][mock_compiler.ext] = mock_compiler # Ensure our coverage tracker is using our new tmp project w/ the new src diff --git a/tests/functional/test_project.py b/tests/functional/test_project.py index 40482d0329..6d70e4e047 100644 --- a/tests/functional/test_project.py +++ b/tests/functional/test_project.py @@ -181,6 +181,7 @@ def test_isolate_in_tempdir_does_not_alter_sources(project): # First, create a bad source. with project.temp_config(contracts_folder="build"): new_src = project.contracts_folder / "newsource.json" + new_src.parent.mkdir(exist_ok=True, parents=True) new_src.write_text("this is not json, oops") project.sources.refresh() # Only need to be called when run with other tests. diff --git a/tests/functional/test_proxy.py b/tests/functional/test_proxy.py index 3a8bd6bd7f..50aaa594ce 100644 --- a/tests/functional/test_proxy.py +++ b/tests/functional/test_proxy.py @@ -6,6 +6,7 @@ def test_minimal_proxy(ethereum, minimal_proxy, chain): + chain.provider.network.__dict__["explorer"] = None # Ensure no explorer, messes up test. actual = ethereum.get_proxy_info(minimal_proxy.address) assert actual is not None assert actual.type == ProxyType.Minimal