Improve test coverage, more e2e tests

Author: THardy98

tests/test_envconfig.py

@@ -612,3 +612,372 @@ def test_client_config_to_from_dict():
     assert empty_config_dict == {}
     new_empty_config = ClientConfig.from_dict(empty_config_dict)
     assert empty_config == new_empty_config
+
+
+def test_grpc_metadata_normalization_from_toml():
+    """Test that gRPC metadata keys get normalized from TOML."""
+    toml_config = textwrap.dedent(
+        """
+        [profile.default]
+        address = "localhost:7233"
+        namespace = "default"
+
+        [profile.default.grpc_meta]
+        "Custom-Header" = "custom-value"
+        "ANOTHER_HEADER_KEY" = "another-value"
+        "mixed_Case-header" = "mixed-value"
+        """
+    )
+
+    profile = ClientConfigProfile.load(config_source=toml_config)
+
+    # Keys should be normalized: uppercase -> lowercase, underscores -> hyphens
+    assert profile.grpc_meta["custom-header"] == "custom-value"
+    assert profile.grpc_meta["another-header-key"] == "another-value"
+    assert profile.grpc_meta["mixed-case-header"] == "mixed-value"
+
+    # Original case variations should not exist
+    assert "Custom-Header" not in profile.grpc_meta
+    assert "ANOTHER_HEADER_KEY" not in profile.grpc_meta
+    assert "mixed_Case-header" not in profile.grpc_meta
+
+    config = profile.to_client_connect_config()
+    rpc_metadata = config.get("rpc_metadata")
+    assert rpc_metadata is not None
+    assert rpc_metadata["custom-header"] == "custom-value"
+    assert rpc_metadata["another-header-key"] == "another-value"
+
+
+def test_grpc_metadata_deletion_via_empty_env_value(base_config_file: Path):
+    """Test that empty environment variable values delete existing gRPC metadata."""
+    env = {
+        # Empty value should remove the header
+        "TEMPORAL_GRPC_META_CUSTOM_HEADER": "",
+        # Non-empty value should set the header
+        "TEMPORAL_GRPC_META_NEW_HEADER": "new-value",
+    }
+    profile = ClientConfigProfile.load(
+        config_source=base_config_file, profile="custom", override_env_vars=env
+    )
+
+    # custom-header should be removed by empty env value
+    assert "custom-header" not in profile.grpc_meta
+    # new-header should be added
+    assert profile.grpc_meta["new-header"] == "new-value"
+
+    config = profile.to_client_connect_config()
+    rpc_metadata = config.get("rpc_metadata")
+    if rpc_metadata:
+        assert "custom-header" not in rpc_metadata
+        assert rpc_metadata["new-header"] == "new-value"
+
+
+def test_default_profile_not_found_returns_empty_profile():
+    """Test that requesting missing 'default' profile returns empty profile instead of error."""
+    toml_config = textwrap.dedent(
+        """
+        [profile.existing]
+        address = "my-address"
+        """
+    )
+    profile = ClientConfigProfile.load(config_source=toml_config)
+    assert profile.address is None
+    assert profile.namespace is None
+    assert profile.api_key is None
+    assert not profile.grpc_meta
+    assert profile.tls is None
+
+
+def test_tls_conflict_across_sources_path_in_toml_data_in_env():
+    """Test error when cert path in TOML conflicts with cert data in env var."""
+    toml_config = textwrap.dedent(
+        """
+        [profile.default]
+        address = "localhost:7233"
+        [profile.default.tls]
+        client_cert_path = "/path/to/cert"
+        """
+    )
+
+    env = {
+        "TEMPORAL_TLS_CLIENT_CERT_DATA": "cert-data-from-env"
+    }
+
+    with pytest.raises(RuntimeError, match="Cannot specify cert data via TEMPORAL_TLS_CLIENT_CERT_DATA when cert path is already specified"):
+        ClientConfigProfile.load(
+            config_source=toml_config,
+            override_env_vars=env
+        )
+
+
+def test_tls_conflict_across_sources_data_in_toml_path_in_env():
+    """Test error when cert data in TOML conflicts with cert path in env var."""
+    toml_config = textwrap.dedent(
+        """
+        [profile.default]
+        address = "localhost:7233"
+        [profile.default.tls]
+        client_cert_data = "cert-data-from-toml"
+        """
+    )
+
+    env = {
+        "TEMPORAL_TLS_CLIENT_CERT_PATH": "/path/from/env"
+    }
+
+    with pytest.raises(RuntimeError, match="Cannot specify cert path via TEMPORAL_TLS_CLIENT_CERT_PATH when cert data is already specified"):
+        ClientConfigProfile.load(
+            config_source=toml_config,
+            override_env_vars=env
+        )
+
+
+def test_load_client_connect_options_convenience_api(base_config_file: Path):
+    """Test the convenience API for loading client connect configuration."""
+    # Test default profile with file
+    config = ClientConfig.load_client_connect_config(config_file=str(base_config_file))
+    assert config.get("target_host") == "default-address"
+    assert config.get("namespace") == "default-namespace"
+
+    # Test with environment overrides
+    env = {"TEMPORAL_NAMESPACE": "env-override-namespace"}
+    config_with_env = ClientConfig.load_client_connect_config(
+        config_file=str(base_config_file), override_env_vars=env
+    )
+    assert config_with_env.get("target_host") == "default-address"
+    assert config_with_env.get("namespace") == "env-override-namespace"
+
+    # Test with specific profile
+    config_custom = ClientConfig.load_client_connect_config(
+        profile="custom", config_file=str(base_config_file)
+    )
+    assert config_custom.get("target_host") == "custom-address"
+    assert config_custom.get("namespace") == "custom-namespace"
+    assert config_custom.get("api_key") == "custom-api-key"
+
+
+def test_load_client_connect_options_e2e_validation():
+    """Test comprehensive end-to-end configuration loading with all features."""
+    toml_content = textwrap.dedent(
+        """
+        [profile.production]
+        address = "prod.temporal.com:443"
+        namespace = "production-ns"
+        api_key = "prod-api-key"
+
+        [profile.production.tls]
+        server_name = "prod.temporal.com"
+        server_ca_cert_data = "prod-ca-cert"
+
+        [profile.production.grpc_meta]
+        authorization = "Bearer prod-token"
+        "x-custom-header" = "prod-value"
+        """
+    )
+
+    env_overrides = {
+        "TEMPORAL_GRPC_META_X_ENVIRONMENT": "production",
+        "TEMPORAL_TLS_SERVER_NAME": "override.temporal.com"
+    }
+
+    config = ClientConfig.load_client_connect_config(
+        profile="production",
+        config_file=None,  # Use config_source directly
+        override_env_vars=env_overrides,
+        disable_file=True  # Load from config_source instead
+    )
+
+    # First load the profile to get the raw config, then convert
+    profile = ClientConfigProfile.load(
+        profile="production",
+        config_source=toml_content,
+        override_env_vars=env_overrides
+    )
+    config = profile.to_client_connect_config()
+
+    # Validate all configuration aspects
+    assert config.get("target_host") == "prod.temporal.com:443"
+    assert config.get("namespace") == "production-ns"
+    assert config.get("api_key") == "prod-api-key"
+
+    # TLS configuration (API key should auto-enable TLS)
+    assert config.get("tls") is not None
+    tls_config = config.get("tls")
+    assert isinstance(tls_config, TLSConfig)
+    assert tls_config.domain == "override.temporal.com"  # Env override
+    assert tls_config.server_root_ca_cert == b"prod-ca-cert"
+
+    # gRPC metadata with normalization and env overrides
+    assert config.get("rpc_metadata") is not None
+    rpc_metadata = config.get("rpc_metadata")
+    assert rpc_metadata is not None
+    assert rpc_metadata["authorization"] == "Bearer prod-token"
+    assert rpc_metadata["x-custom-header"] == "prod-value"
+    assert rpc_metadata["x-environment"] == "production"  # From env
+
+
+async def test_e2e_basic_development_profile_client_connection(client: Client):
+    """Test basic development profile with actual client connection."""
+    # Get connection details from the fixture client
+    target_host = client.service_client.config.target_host
+    namespace = client.namespace
+
+    toml_content = textwrap.dedent(
+        f"""
+        [profile.development]
+        address = "{target_host}"
+        namespace = "{namespace}"
+
+        [profile.development.grpc_meta]
+        "x-test-source" = "envconfig-python-dev"
+        """
+    )
+
+    profile = ClientConfigProfile.load(
+        profile="development",
+        config_source=toml_content
+    )
+
+    config = profile.to_client_connect_config()
+
+    # Create actual Temporal client using envconfig
+    new_client = await Client.connect(**config)
+
+    # Verify client configuration matches envconfig
+    assert new_client.service_client.config.target_host == target_host
+    assert new_client.namespace == namespace
+    if new_client.service_client.config.rpc_metadata:
+        assert new_client.service_client.config.rpc_metadata["x-test-source"] == "envconfig-python-dev"
+
+
+async def test_e2e_production_tls_api_key_client_connection(client: Client):
+    """Test production profile with TLS and API key with actual client connection."""
+    # Get connection details from the fixture client
+    target_host = client.service_client.config.target_host
+
+    toml_content = textwrap.dedent(
+        f"""
+        [profile.production]
+        address = "{target_host}"
+        namespace = "production-namespace"
+        api_key = "prod-api-key-123"
+
+        [profile.production.tls]
+        disabled = true
+
+        [profile.production.grpc_meta]
+        authorization = "Bearer prod-token"
+        "x-environment" = "production"
+        """
+    )
+
+    profile = ClientConfigProfile.load(
+        profile="production",
+        config_source=toml_content
+    )
+
+    config = profile.to_client_connect_config()
+
+    # Create TLS-enabled client with API key
+    new_client = await Client.connect(**config)
+
+    # Verify production configuration
+    assert new_client.service_client.config.target_host == target_host
+    assert new_client.namespace == "production-namespace"
+    assert new_client.service_client.config.api_key == "prod-api-key-123"
+    if new_client.service_client.config.rpc_metadata:
+        assert new_client.service_client.config.rpc_metadata["authorization"] == "Bearer prod-token"
+        assert new_client.service_client.config.rpc_metadata["x-environment"] == "production"
+
+
+async def test_e2e_environment_overrides_client_connection(client: Client):
+    """Test environment overrides with actual client connection."""
+    # Get connection details from the fixture client
+    target_host = client.service_client.config.target_host
+
+    toml_content = textwrap.dedent(
+        """
+        [profile.staging]
+        address = "staging.temporal.com:443"
+        namespace = "staging-namespace"
+
+        [profile.staging.grpc_meta]
+        "x-deployment" = "staging"
+        authorization = "Bearer staging-token"
+        """
+    )
+
+    env_overrides = {
+        "TEMPORAL_ADDRESS": target_host,
+        "TEMPORAL_NAMESPACE": "override-namespace",
+        "TEMPORAL_GRPC_META_X_DEPLOYMENT": "canary",
+        "TEMPORAL_GRPC_META_AUTHORIZATION": "Bearer override-token"
+    }
+
+    profile = ClientConfigProfile.load(
+        profile="staging",
+        config_source=toml_content,
+        override_env_vars=env_overrides
+    )
+
+    config = profile.to_client_connect_config()
+
+    # Create client with environment overrides
+    new_client = await Client.connect(**config)
+
+    # Verify environment overrides took effect
+    assert new_client.service_client.config.target_host == target_host
+    assert new_client.namespace == "override-namespace"
+    if new_client.service_client.config.rpc_metadata:
+        assert new_client.service_client.config.rpc_metadata["x-deployment"] == "canary"
+        assert new_client.service_client.config.rpc_metadata["authorization"] == "Bearer override-token"
+
+
+async def test_e2e_multi_profile_different_client_connections(client: Client):
+    """Test multiple profiles creating different client connections."""
+    # Get connection details from the fixture client
+    target_host = client.service_client.config.target_host
+
+    toml_content = textwrap.dedent(
+        f"""
+        [profile.development]
+        address = "{target_host}"
+        namespace = "dev"
+
+        [profile.production]
+        address = "{target_host}"
+        namespace = "prod"
+        api_key = "prod-key"
+
+        [profile.production.tls]
+        disabled = true
+        """
+    )
+
+    # Load and create development client
+    dev_profile = ClientConfigProfile.load(
+        profile="development",
+        config_source=toml_content
+    )
+
+    dev_config = dev_profile.to_client_connect_config()
+    dev_client = await Client.connect(**dev_config)
+
+    # Load and create production client
+    prod_profile = ClientConfigProfile.load(
+        profile="production",
+        config_source=toml_content
+    )
+
+    prod_config = prod_profile.to_client_connect_config()
+    prod_client = await Client.connect(**prod_config)
+
+    # Verify different configurations for each client
+    assert dev_client.service_client.config.target_host == target_host
+    assert dev_client.namespace == "dev"
+    assert dev_client.service_client.config.api_key is None
+    assert dev_client.service_client.config.tls is False
+
+    assert prod_client.service_client.config.target_host == target_host
+    assert prod_client.namespace == "prod"
+    assert prod_client.service_client.config.api_key == "prod-key"