genlayer-test 0.4.1__py3-none-any.whl → 2.0.0__py3-none-any.whl

tests/gltest_cli/config/test_general_config.py

@@ -0,0 +1,406 @@
+import pytest
+from pathlib import Path
+from gltest_cli.config.types import (
+    GeneralConfig,
+    UserConfig,
+    PluginConfig,
+    PathConfig,
+    NetworkConfigData,
+)
+from gltest_cli.config.constants import DEFAULT_ARTIFACTS_DIR, DEFAULT_CONTRACTS_DIR
+
+
+def test_general_config_artifacts_methods():
+    """Test GeneralConfig artifacts directory methods."""
+    user_config = UserConfig(
+        networks={"localnet": NetworkConfigData()},
+        paths=PathConfig(contracts=Path("contracts"), artifacts=Path("user_artifacts")),
+    )
+
+    plugin_config = PluginConfig()
+    general_config = GeneralConfig(user_config=user_config, plugin_config=plugin_config)
+
+    # Test get_artifacts_dir returns user config value when plugin config is not set
+    assert general_config.get_artifacts_dir() == Path("user_artifacts")
+
+    # Test set_artifacts_dir updates plugin config
+    general_config.set_artifacts_dir(Path("plugin_artifacts"))
+    assert general_config.get_artifacts_dir() == Path("plugin_artifacts")
+
+    # Plugin config should take precedence
+    assert general_config.plugin_config.artifacts_dir == Path("plugin_artifacts")
+
+
+def test_general_config_artifacts_default():
+    """Test GeneralConfig artifacts directory with default values."""
+    user_config = UserConfig(
+        networks={"localnet": NetworkConfigData()},
+        paths=PathConfig(artifacts=DEFAULT_ARTIFACTS_DIR),
+    )
+
+    plugin_config = PluginConfig()
+    general_config = GeneralConfig(user_config=user_config, plugin_config=plugin_config)
+
+    # Should return default artifacts directory
+    assert general_config.get_artifacts_dir() == DEFAULT_ARTIFACTS_DIR
+
+
+def test_general_config_artifacts_plugin_precedence():
+    """Test that plugin config takes precedence over user config for artifacts."""
+    user_config = UserConfig(
+        networks={"localnet": NetworkConfigData()},
+        paths=PathConfig(artifacts=Path("user_artifacts")),
+    )
+
+    plugin_config = PluginConfig(artifacts_dir=Path("plugin_artifacts"))
+    general_config = GeneralConfig(user_config=user_config, plugin_config=plugin_config)
+
+    # Plugin config should take precedence
+    assert general_config.get_artifacts_dir() == Path("plugin_artifacts")
+
+
+def test_general_config_artifacts_none_values():
+    """Test GeneralConfig behavior when artifacts paths are None."""
+    user_config = UserConfig(
+        networks={"localnet": NetworkConfigData()}, paths=PathConfig(artifacts=None)
+    )
+
+    plugin_config = PluginConfig(artifacts_dir=None)
+    general_config = GeneralConfig(user_config=user_config, plugin_config=plugin_config)
+
+    # Should return None when both are None
+    assert general_config.get_artifacts_dir() is None
+
+
+def test_general_config_both_contracts_and_artifacts():
+    """Test that both contracts and artifacts directories work together."""
+    user_config = UserConfig(
+        networks={"localnet": NetworkConfigData()},
+        paths=PathConfig(
+            contracts=Path("src/contracts"), artifacts=Path("build/artifacts")
+        ),
+    )
+
+    plugin_config = PluginConfig(
+        contracts_dir=Path("custom/contracts"), artifacts_dir=Path("custom/artifacts")
+    )
+
+    general_config = GeneralConfig(user_config=user_config, plugin_config=plugin_config)
+
+    # Both should return plugin values (precedence)
+    assert general_config.get_contracts_dir() == Path("custom/contracts")
+    assert general_config.get_artifacts_dir() == Path("custom/artifacts")
+
+
+def test_general_config_mixed_precedence():
+    """Test mixed precedence where only one path is overridden in plugin."""
+    user_config = UserConfig(
+        networks={"localnet": NetworkConfigData()},
+        paths=PathConfig(
+            contracts=Path("user/contracts"), artifacts=Path("user/artifacts")
+        ),
+    )
+
+    # Only override artifacts in plugin config
+    plugin_config = PluginConfig(artifacts_dir=Path("plugin/artifacts"))
+    general_config = GeneralConfig(user_config=user_config, plugin_config=plugin_config)
+
+    # Contracts should come from user config, artifacts from plugin config
+    assert general_config.get_contracts_dir() == Path("user/contracts")
+    assert general_config.get_artifacts_dir() == Path("plugin/artifacts")
+
+
+def test_path_config_validation():
+    """Test PathConfig validation for artifacts."""
+    # Valid path configurations
+    valid_config = PathConfig(contracts=Path("contracts"), artifacts=Path("artifacts"))
+    assert valid_config.contracts == Path("contracts")
+    assert valid_config.artifacts == Path("artifacts")
+
+    # Test with string paths
+    string_config = PathConfig(contracts="contracts", artifacts="artifacts")
+    # PathConfig should handle string conversion in __post_init__
+    assert string_config.contracts == "contracts"
+    assert string_config.artifacts == "artifacts"
+
+
+def test_path_config_invalid_types():
+    """Test PathConfig validation with invalid types."""
+    # Test invalid artifacts type
+    with pytest.raises(ValueError, match="artifacts must be a string or Path"):
+        PathConfig(artifacts=123)
+
+    # Test invalid contracts type (existing validation)
+    with pytest.raises(ValueError, match="contracts must be a string or Path"):
+        PathConfig(contracts=123)
+
+
+def test_general_config_contracts_default():
+    """Test GeneralConfig contracts directory with default values."""
+    user_config = UserConfig(
+        networks={"localnet": NetworkConfigData()},
+        paths=PathConfig(contracts=DEFAULT_CONTRACTS_DIR),
+    )
+
+    plugin_config = PluginConfig()
+    general_config = GeneralConfig(user_config=user_config, plugin_config=plugin_config)
+
+    # Should return default contracts directory
+    assert general_config.get_contracts_dir() == DEFAULT_CONTRACTS_DIR
+
+
+def test_general_config_leader_only_default():
+    """Test GeneralConfig leader_only with default values."""
+    user_config = UserConfig(
+        networks={"localnet": NetworkConfigData()},
+    )
+
+    plugin_config = PluginConfig()
+    general_config = GeneralConfig(user_config=user_config, plugin_config=plugin_config)
+
+    # Should return False by default
+    assert general_config.get_leader_only() is False
+
+
+def test_general_config_leader_only_network_config():
+    """Test GeneralConfig leader_only from network configuration."""
+    user_config = UserConfig(
+        networks={"localnet": NetworkConfigData(leader_only=True)},
+        default_network="localnet",
+    )
+
+    plugin_config = PluginConfig()
+    general_config = GeneralConfig(user_config=user_config, plugin_config=plugin_config)
+
+    # Should return True from network config
+    assert general_config.get_leader_only() is True
+
+
+def test_general_config_leader_only_plugin_precedence():
+    """Test that plugin config takes precedence over network config for leader_only."""
+    user_config = UserConfig(
+        networks={"localnet": NetworkConfigData(leader_only=False)},
+        default_network="localnet",
+    )
+
+    plugin_config = PluginConfig(leader_only=True)
+    general_config = GeneralConfig(user_config=user_config, plugin_config=plugin_config)
+
+    # Plugin config should take precedence
+    assert general_config.get_leader_only() is True
+
+
+def test_general_config_leader_only_multiple_networks():
+    """Test leader_only with multiple networks."""
+    user_config = UserConfig(
+        networks={
+            "localnet": NetworkConfigData(leader_only=False),
+            "testnet": NetworkConfigData(leader_only=True),
+        },
+        default_network="testnet",
+    )
+
+    plugin_config = PluginConfig()
+    general_config = GeneralConfig(user_config=user_config, plugin_config=plugin_config)
+
+    # Should use the default network's leader_only value
+    assert general_config.get_leader_only() is True
+
+    # Change network via plugin config
+    plugin_config.network_name = "localnet"
+    general_config = GeneralConfig(user_config=user_config, plugin_config=plugin_config)
+    assert general_config.get_leader_only() is False
+
+
+def test_general_config_leader_only_network_not_found():
+    """Test leader_only when selected network is not found."""
+    user_config = UserConfig(
+        networks={"localnet": NetworkConfigData(leader_only=True)},
+        default_network="localnet",
+    )
+
+    plugin_config = PluginConfig(network_name="nonexistent")
+    general_config = GeneralConfig(user_config=user_config, plugin_config=plugin_config)
+
+    # Should return False when network is not found
+    assert general_config.get_leader_only() is False
+
+
+def test_check_local_rpc_with_localhost():
+    """Test check_local_rpc with localhost URL."""
+    user_config = UserConfig(
+        networks={"localnet": NetworkConfigData(url="http://localhost:8545")},
+        default_network="localnet",
+    )
+
+    plugin_config = PluginConfig()
+    general_config = GeneralConfig(user_config=user_config, plugin_config=plugin_config)
+
+    assert general_config.check_local_rpc() is True
+
+
+def test_check_local_rpc_with_127_0_0_1():
+    """Test check_local_rpc with 127.0.0.1 URL."""
+    user_config = UserConfig(
+        networks={"localnet": NetworkConfigData(url="http://127.0.0.1:8545")},
+        default_network="localnet",
+    )
+
+    plugin_config = PluginConfig()
+    general_config = GeneralConfig(user_config=user_config, plugin_config=plugin_config)
+
+    assert general_config.check_local_rpc() is True
+
+
+def test_check_local_rpc_with_external_url():
+    """Test check_local_rpc with external URL."""
+    user_config = UserConfig(
+        networks={"testnet": NetworkConfigData(url="https://api.genlayer.com:8545")},
+        default_network="testnet",
+    )
+
+    plugin_config = PluginConfig()
+    general_config = GeneralConfig(user_config=user_config, plugin_config=plugin_config)
+
+    assert general_config.check_local_rpc() is False
+
+
+def test_check_local_rpc_with_plugin_override():
+    """Test check_local_rpc with plugin config RPC URL override."""
+    user_config = UserConfig(
+        networks={"localnet": NetworkConfigData(url="https://external.com")},
+        default_network="localnet",
+    )
+
+    plugin_config = PluginConfig(rpc_url="http://localhost:9000")
+    general_config = GeneralConfig(user_config=user_config, plugin_config=plugin_config)
+
+    # Plugin config should take precedence
+    assert general_config.check_local_rpc() is True
+
+
+def test_check_studio_based_rpc_with_localhost():
+    """Test check_studio_based_rpc with localhost URL."""
+    user_config = UserConfig(
+        networks={"localnet": NetworkConfigData(url="http://localhost:8545")},
+        default_network="localnet",
+    )
+
+    plugin_config = PluginConfig()
+    general_config = GeneralConfig(user_config=user_config, plugin_config=plugin_config)
+
+    assert general_config.check_studio_based_rpc() is True
+
+
+def test_check_studio_based_rpc_with_127_0_0_1():
+    """Test check_studio_based_rpc with 127.0.0.1 URL."""
+    user_config = UserConfig(
+        networks={"localnet": NetworkConfigData(url="http://127.0.0.1:8545")},
+        default_network="localnet",
+    )
+
+    plugin_config = PluginConfig()
+    general_config = GeneralConfig(user_config=user_config, plugin_config=plugin_config)
+
+    assert general_config.check_studio_based_rpc() is True
+
+
+def test_check_studio_based_rpc_with_genlayer_subdomain():
+    """Test check_studio_based_rpc with .genlayer.com subdomains."""
+    test_cases = [
+        "https://api.genlayer.com:8545",
+        "https://test.genlayer.com",
+        "http://staging.api.genlayer.com:9000",
+        "https://dev.test.genlayer.com",
+    ]
+
+    for url in test_cases:
+        user_config = UserConfig(
+            networks={"testnet": NetworkConfigData(url=url)},
+            default_network="testnet",
+        )
+
+        plugin_config = PluginConfig()
+        general_config = GeneralConfig(
+            user_config=user_config, plugin_config=plugin_config
+        )
+
+        assert general_config.check_studio_based_rpc() is True, f"Failed for URL: {url}"
+
+
+def test_check_studio_based_rpc_with_genlayerlabs_subdomain():
+    """Test check_studio_based_rpc with .genlayerlabs.com subdomains."""
+    test_cases = [
+        "https://api.genlayerlabs.com:8545",
+        "https://test.genlayerlabs.com",
+        "http://staging.api.genlayerlabs.com:9000",
+        "https://dev.test.genlayerlabs.com",
+    ]
+
+    for url in test_cases:
+        user_config = UserConfig(
+            networks={"testnet": NetworkConfigData(url=url)},
+            default_network="testnet",
+        )
+
+        plugin_config = PluginConfig()
+        general_config = GeneralConfig(
+            user_config=user_config, plugin_config=plugin_config
+        )
+
+        assert general_config.check_studio_based_rpc() is True, f"Failed for URL: {url}"
+
+
+def test_check_studio_based_rpc_with_non_genlayer_domain():
+    """Test check_studio_based_rpc with non-GenLayer domains."""
+    test_cases = [
+        "https://api.example.com:8545",
+        "https://test.otherdomain.com",
+        "http://staging.api.random.org:9000",
+        "https://genlayer.example.com",  # Not a subdomain of .genlayer.com
+        "https://genlayerlabs.example.com",  # Not a subdomain of .genlayerlabs.com
+    ]
+
+    for url in test_cases:
+        user_config = UserConfig(
+            networks={"testnet": NetworkConfigData(url=url)},
+            default_network="testnet",
+        )
+
+        plugin_config = PluginConfig()
+        general_config = GeneralConfig(
+            user_config=user_config, plugin_config=plugin_config
+        )
+
+        assert (
+            general_config.check_studio_based_rpc() is False
+        ), f"Failed for URL: {url}"
+
+
+def test_check_studio_based_rpc_with_plugin_override():
+    """Test check_studio_based_rpc with plugin config RPC URL override."""
+    # User config has external URL, but plugin overrides with GenLayer domain
+    user_config = UserConfig(
+        networks={"localnet": NetworkConfigData(url="https://external.com")},
+        default_network="localnet",
+    )
+
+    plugin_config = PluginConfig(rpc_url="https://api.genlayer.com:9000")
+    general_config = GeneralConfig(user_config=user_config, plugin_config=plugin_config)
+
+    # Plugin config should take precedence
+    assert general_config.check_studio_based_rpc() is True
+
+    # Test opposite case: user has GenLayer domain, plugin overrides with external
+    user_config2 = UserConfig(
+        networks={"localnet": NetworkConfigData(url="https://api.genlayer.com")},
+        default_network="localnet",
+    )
+
+    plugin_config2 = PluginConfig(rpc_url="https://external.com:9000")
+    general_config2 = GeneralConfig(
+        user_config=user_config2, plugin_config=plugin_config2
+    )
+
+    # Plugin config should take precedence
+    assert general_config2.check_studio_based_rpc() is False

tests/gltest_cli/config/test_plugin.py

@@ -8,6 +8,8 @@ def test_help_message(pytester):
             "gltest:",
             "  --contracts-dir=CONTRACTS_DIR",
             "                        Path to directory containing contract files",
+            "  --artifacts-dir=ARTIFACTS_DIR",
+            "                        Path to directory for storing contract artifacts",
             "  --default-wait-interval=DEFAULT_WAIT_INTERVAL",
             "                        Default interval (ms) between transaction receipt checks",
             "  --default-wait-retries=DEFAULT_WAIT_RETRIES",
@@ -15,6 +17,8 @@ def test_help_message(pytester):
             "  --rpc-url=RPC_URL     RPC endpoint URL for the GenLayer network",
             "  --network=NETWORK     Target network (defaults to 'localnet' if no config",
             "                        file)",
+            "  --test-with-mocks     Test with mocks",
+            "  --leader-only         Run contracts in leader-only mode",
         ]
     )
 
@@ -125,3 +129,166 @@ def test_network_testnet(pytester):
         ]
     )
     assert result.ret == 0
+
+
+def test_artifacts_dir(pytester):
+    """Test that artifacts directory CLI parameter works correctly."""
+    pytester.makepyfile(
+        """
+        from gltest_cli.config.general import get_general_config
+        from pathlib import Path
+
+        def test_artifacts_dir():
+            general_config = get_general_config()
+            assert general_config.get_artifacts_dir() == Path("custom/artifacts")
+    """
+    )
+
+    result = pytester.runpytest("--artifacts-dir=custom/artifacts", "-v")
+
+    result.stdout.fnmatch_lines(
+        [
+            "*::test_artifacts_dir PASSED*",
+        ]
+    )
+    assert result.ret == 0
+
+
+def test_contracts_and_artifacts_dirs(pytester):
+    """Test that both contracts and artifacts directories can be set via CLI."""
+    pytester.makepyfile(
+        """
+        from gltest_cli.config.general import get_general_config
+        from pathlib import Path
+
+        def test_both_dirs():
+            general_config = get_general_config()
+            assert general_config.get_contracts_dir() == Path("src/contracts")
+            assert general_config.get_artifacts_dir() == Path("build/artifacts")
+    """
+    )
+
+    result = pytester.runpytest(
+        "--contracts-dir=src/contracts", "--artifacts-dir=build/artifacts", "-v"
+    )
+
+    result.stdout.fnmatch_lines(
+        [
+            "*::test_both_dirs PASSED*",
+        ]
+    )
+    assert result.ret == 0
+
+
+def test_test_with_mocks_true(pytester):
+    pytester.makepyfile(
+        """
+        from gltest_cli.config.general import get_general_config
+
+        def test_test_with_mocks():
+            general_config = get_general_config()
+            assert general_config.get_test_with_mocks() == True
+    """
+    )
+
+    result = pytester.runpytest("--test-with-mocks", "-v")
+
+    result.stdout.fnmatch_lines(
+        [
+            "*::test_test_with_mocks PASSED*",
+        ]
+    )
+    assert result.ret == 0
+
+
+def test_test_with_mocks_false(pytester):
+    pytester.makepyfile(
+        """
+        from gltest_cli.config.general import get_general_config
+
+        def test_test_with_mocks():
+            general_config = get_general_config()
+            assert general_config.get_test_with_mocks() == False
+            "*::test_test_with_mocks PASSED*",
+
+    """
+    )
+
+    result = pytester.runpytest("-v")
+
+    result.stdout.fnmatch_lines(
+        [
+            "*::test_test_with_mocks PASSED*",
+        ]
+    )
+    assert result.ret == 0
+
+
+def test_artifacts_dir_default_fallback(pytester):
+    """Test that artifacts directory falls back to config file default when CLI not provided."""
+    pytester.makepyfile(
+        """
+        from gltest_cli.config.general import get_general_config
+        from pathlib import Path
+
+        def test_artifacts_default():
+            general_config = get_general_config()
+            # Should use the default from config
+            artifacts_dir = general_config.get_artifacts_dir()
+            assert isinstance(artifacts_dir, Path)
+            # Default should be 'artifacts' 
+            assert str(artifacts_dir) == "artifacts"
+
+    """
+    )
+
+    result = pytester.runpytest("-v")
+
+    result.stdout.fnmatch_lines(
+        [
+            "*::test_artifacts_default PASSED*",
+        ]
+    )
+    assert result.ret == 0
+
+
+def test_leader_only_true(pytester):
+    pytester.makepyfile(
+        """
+        from gltest_cli.config.general import get_general_config
+
+        def test_leader_only():
+            general_config = get_general_config()
+            assert general_config.get_leader_only() == True
+    """
+    )
+
+    result = pytester.runpytest("--leader-only", "-v")
+
+    result.stdout.fnmatch_lines(
+        [
+            "*::test_leader_only PASSED*",
+        ]
+    )
+    assert result.ret == 0
+
+
+def test_leader_only_false(pytester):
+    pytester.makepyfile(
+        """
+        from gltest_cli.config.general import get_general_config
+
+        def test_leader_only():
+            general_config = get_general_config()
+            assert general_config.get_leader_only() == False
+    """
+    )
+
+    result = pytester.runpytest("-v")
+
+    result.stdout.fnmatch_lines(
+        [
+            "*::test_leader_only PASSED*",
+        ]
+    )
+    assert result.ret == 0

tests/gltest_cli/config/test_user.py

@@ -11,6 +11,7 @@ from gltest_cli.config.user import (
     DEFAULT_NETWORK,
     DEFAULT_ENVIRONMENT,
     DEFAULT_CONTRACTS_DIR,
+    DEFAULT_ARTIFACTS_DIR,
 )
 from gltest_cli.config.constants import DEFAULT_RPC_URL
 from gltest_cli.config.types import UserConfig, NetworkConfigData, PathConfig
@@ -33,7 +34,7 @@ VALID_CONFIG = {
             "from": "0x123",
         },
     },
-    "paths": {"contracts": "contracts"},
+    "paths": {"contracts": "contracts", "artifacts": "artifacts"},
     "environment": ".env",
 }
 
@@ -73,6 +74,7 @@ def test_get_default_user_config():
     # Check paths
     assert isinstance(config.paths, PathConfig)
     assert config.paths.contracts == DEFAULT_CONTRACTS_DIR
+    assert config.paths.artifacts == DEFAULT_ARTIFACTS_DIR
 
     # Check environment
     assert config.environment == DEFAULT_ENVIRONMENT
@@ -135,6 +137,11 @@ def test_validate_raw_user_config_invalid():
             {"networks": {"default": "localnet", "localnet": {"from": 123}}}
         )
 
+    with pytest.raises(ValueError, match="leader_only must be a boolean"):
+        validate_raw_user_config(
+            {"networks": {"default": "localnet", "localnet": {"leader_only": "true"}}}
+        )
+
     with pytest.raises(ValueError, match="paths must be a dictionary"):
         validate_raw_user_config({"paths": "not_a_dict"})
 
@@ -180,6 +187,11 @@ def test_validate_raw_user_config_invalid():
             {"networks": {"default": "localnet", "testnet": {"from": 123}}}
         )
 
+    with pytest.raises(ValueError, match="leader_only must be a boolean"):
+        validate_raw_user_config(
+            {"networks": {"default": "localnet", "testnet": {"leader_only": "true"}}}
+        )
+
     # Test required fields for non-default networks
     with pytest.raises(ValueError, match="network testnet must have an id"):
         validate_raw_user_config(
@@ -255,6 +267,7 @@ def test_load_user_config(mock_load_dotenv, mock_file):
     # Check paths
     assert isinstance(config.paths, PathConfig)
     assert config.paths.contracts == Path("contracts")
+    assert config.paths.artifacts == Path("artifacts")
 
     # Check environment
     assert config.environment == ".env"
@@ -349,3 +362,50 @@ def test_user_config_exists(mock_cwd):
     # Test with no files
     mock_path.iterdir.return_value = []
     assert user_config_exists() is False
+
+
+# Tests for artifacts directory functionality
+def test_artifacts_path_in_config():
+    """Test that artifacts path is properly handled in configuration."""
+    config_with_artifacts = {
+        "networks": {"default": "localnet"},
+        "paths": {"contracts": "contracts", "artifacts": "build/artifacts"},
+    }
+
+    config = transform_raw_to_user_config_with_defaults(config_with_artifacts)
+    assert config.paths.artifacts == Path("build/artifacts")
+
+
+def test_artifacts_path_defaults():
+    """Test that artifacts path defaults to DEFAULT_ARTIFACTS_DIR when not specified."""
+    config_without_artifacts = {
+        "networks": {"default": "localnet"},
+        "paths": {"contracts": "contracts"},
+    }
+
+    config = transform_raw_to_user_config_with_defaults(config_without_artifacts)
+    assert config.paths.artifacts == DEFAULT_ARTIFACTS_DIR
+
+
+def test_artifacts_path_validation():
+    """Test validation of artifacts path configuration."""
+    # Valid config with artifacts
+    valid_config = {"paths": {"artifacts": "custom/artifacts"}}
+    validate_raw_user_config(valid_config)  # Should not raise
+
+    # Test that artifacts is included in valid path keys
+    from gltest_cli.config.user import VALID_PATHS_KEYS
+
+    assert "artifacts" in VALID_PATHS_KEYS
+
+
+def test_artifacts_path_only_config():
+    """Test configuration with only artifacts path specified."""
+    config_artifacts_only = {
+        "networks": {"default": "localnet"},
+        "paths": {"artifacts": "my_artifacts"},
+    }
+
+    config = transform_raw_to_user_config_with_defaults(config_artifacts_only)
+    assert config.paths.contracts == DEFAULT_CONTRACTS_DIR
+    assert config.paths.artifacts == Path("my_artifacts")