fix(_patch_enum_parse_value): Fix patching enum values

Author: KarolJagodzinski

ariadne/enums_default_values.py

@@ -1,4 +1,5 @@
 from collections.abc import Callable
+from enum import Enum
 from typing import Any
 
 from graphql import (
@@ -152,9 +153,13 @@ def make_patched_parse_value(
         original: Callable[[str], Any],
     ) -> Callable[[Any], Any]:
         def patched_parse_value(input_value: Any) -> Any:
-            # Check if already a valid Python enum value
+            # If input is an Enum instance or a non-string (e.g. int), return as-is.
+            # If input is a string, parse to convert to the enum object.
+            # For StrEnum, strings matching member names should be converted to
+            # enum objects.
             if input_value in enum_type._value_lookup:
-                return input_value
+                if isinstance(input_value, Enum) or not isinstance(input_value, str):
+                    return input_value
             return original(input_value)
 
         return patched_parse_value

tests/test_graphql_enum_fixes.py

@@ -586,3 +586,156 @@ def test_invalid_default_field_input_arg_object_enum_list_value_fails_validation
         )
 
     assert "Undefined enum value" in str(exc_info.value)
+
+
+class StrEnumMatchingValue(str, Enum):
+    """StrEnum where value equals name (e.g., ACTIVE = "ACTIVE")."""
+
+    ACTIVE = "ACTIVE"
+    INACTIVE = "INACTIVE"
+
+
+class StrEnumDifferentValue(str, Enum):
+    """StrEnum where value differs from name (e.g., USER = "u")."""
+
+    USER = "u"
+    ADMIN = "a"
+
+
+class IntEnumType(int, Enum):
+    """IntEnum with integer values."""
+
+    LOW = 0
+    HIGH = 1
+
+
+class PlainEnumType(Enum):
+    """Plain Enum without type mixin."""
+
+    FOO = "foo_value"
+    BAR = "bar_value"
+
+
+@pytest.mark.parametrize(
+    "enum_class,member_name,expected_member",
+    [
+        (StrEnumMatchingValue, "ACTIVE", StrEnumMatchingValue.ACTIVE),
+        (StrEnumDifferentValue, "ADMIN", StrEnumDifferentValue.ADMIN),
+        (IntEnumType, "HIGH", IntEnumType.HIGH),
+        (PlainEnumType, "FOO", PlainEnumType.FOO),
+    ],
+    ids=[
+        "str_enum_matching_value",
+        "str_enum_different_value",
+        "int_enum",
+        "plain_enum",
+    ],
+)
+def test_enum_inline_literal_returns_enum_object(
+    enum_class, member_name, expected_member
+):
+    """Enum inline literal is parsed to correct enum object."""
+    enum_name = enum_class.__name__
+    members = " ".join(m.name for m in enum_class)
+    captured = {}
+
+    schema = make_executable_schema(
+        f"""
+        enum {enum_name} {{ {members} }}
+        type Query {{ getValue(arg: {enum_name}!): String! }}
+        """,
+        enum_class,
+    )
+
+    def resolver(*_, arg):
+        captured["value"] = arg
+        return "ok"
+
+    set_resolver(schema, "getValue", resolver)
+
+    result = graphql_sync(schema, f"{{ getValue(arg: {member_name}) }}")
+
+    assert not result.errors
+    assert captured["value"] is expected_member
+
+
+@pytest.mark.parametrize(
+    "enum_class,member_name,expected_member",
+    [
+        (StrEnumMatchingValue, "ACTIVE", StrEnumMatchingValue.ACTIVE),
+        (StrEnumDifferentValue, "ADMIN", StrEnumDifferentValue.ADMIN),
+        (IntEnumType, "HIGH", IntEnumType.HIGH),
+        (PlainEnumType, "BAR", PlainEnumType.BAR),
+    ],
+    ids=[
+        "str_enum_matching_value",
+        "str_enum_different_value",
+        "int_enum",
+        "plain_enum",
+    ],
+)
+def test_enum_from_variable_returns_enum_object(
+    enum_class, member_name, expected_member
+):
+    """Enum from variable is parsed to correct enum object."""
+    enum_name = enum_class.__name__
+    members = " ".join(m.name for m in enum_class)
+    captured = {}
+
+    schema = make_executable_schema(
+        f"""
+        enum {enum_name} {{ {members} }}
+        type Query {{ getValue(arg: {enum_name}!): String! }}
+        """,
+        enum_class,
+    )
+
+    def resolver(*_, arg):
+        captured["value"] = arg
+        return "ok"
+
+    set_resolver(schema, "getValue", resolver)
+
+    result = graphql_sync(
+        schema,
+        f"query($v: {enum_name}!) {{ getValue(arg: $v) }}",
+        variable_values={"v": member_name},
+    )
+
+    assert not result.errors
+    assert captured["value"] is expected_member
+
+
+@pytest.mark.parametrize(
+    "enum_class,member_name,expected_member",
+    [
+        (StrEnumMatchingValue, "ACTIVE", StrEnumMatchingValue.ACTIVE),
+        (StrEnumDifferentValue, "USER", StrEnumDifferentValue.USER),
+        (IntEnumType, "LOW", IntEnumType.LOW),
+        (PlainEnumType, "FOO", PlainEnumType.FOO),
+    ],
+    ids=[
+        "str_enum_matching_value",
+        "str_enum_different_value",
+        "int_enum",
+        "plain_enum",
+    ],
+)
+def test_parse_value_returns_enum_object(enum_class, member_name, expected_member):
+    """parse_value returns enum object, not the raw string."""
+    enum_name = enum_class.__name__
+    members = " ".join(m.name for m in enum_class)
+
+    schema = make_executable_schema(
+        f"""
+        enum {enum_name} {{ {members} }}
+        type Query {{ value: {enum_name} }}
+        """,
+        enum_class,
+    )
+
+    enum_type = schema.type_map[enum_name]
+    parsed = enum_type.parse_value(member_name)
+
+    assert isinstance(parsed, enum_class)
+    assert parsed is expected_member