refactor(tests): Consolidate event tests into test_event.py

Merge test_event_message.py and test_workflow_events.py into test_event.py to simplify the test suite and keep all Event class behavior tests in a single place.

Change-Id: I99223f44e54fce8d37c5d632358e4343a8dc526d

Author: DeanChensj

tests/unittests/events/test_event.py

@@ -14,11 +14,14 @@
 
 from __future__ import annotations
 
-"""Unit tests for the helper methods on the Event class."""
+"""Unit tests for the Event class."""
 
 from google.adk.events.event import Event
+from google.adk.events.event import NodeInfo
 from google.adk.events.event_actions import EventActions
+from google.adk.events.request_input import RequestInput
 from google.genai import types
+import pytest
 
 
 def _text_part(text: str = 'hello') -> types.Part:
@@ -188,3 +191,237 @@ def test_event_ids_are_unique():
 
 def test_event_id_preserved_when_provided():
   assert _event(id='fixed-id').id == 'fixed-id'
+
+
+# --- state initialization ----------------------------------------------------
+
+
+def test_event_constructor_with_state():
+  """Tests that the event constructor handles the state argument."""
+  my_event = Event(state={'key': 'value'})
+  assert my_event.actions is not None
+  assert my_event.actions.state_delta == {'key': 'value'}
+
+
+def test_event_constructor_without_state():
+  """Tests that the event constructor works without the state argument."""
+  my_event = Event()
+  assert my_event.actions is not None
+  assert my_event.actions.state_delta == {}
+
+
+# --- isolation scope ---------------------------------------------------------
+
+
+def test_event_isolation_scope():
+  """Tests Event.isolation_scope default value and serialization."""
+  ev = Event()
+  assert ev.isolation_scope is None
+
+  ev2 = Event(isolation_scope='task:fc-123')
+  dumped = ev2.model_dump(mode='json', by_alias=True, exclude_none=True)
+  assert dumped['isolationScope'] == 'task:fc-123'
+
+
+# --- serialization -----------------------------------------------------------
+
+
+def test_event_serialization_always_camel_case():
+  """Tests that Event serialization produces camelCase keys."""
+  request_input = RequestInput(interrupt_id='fc-1', message='test')
+
+  # Create an event with fields that would produce snake_case if not dumped by alias
+  event = Event(
+      invocation_id='i-1',
+      node_info=NodeInfo(
+          path='a/b',
+          output_for=['c'],
+          message_as_output=True,
+      ),
+      output=request_input,
+  )
+
+  dumped = event.model_dump(by_alias=True)
+
+  def check_no_snake_case_keys(data):
+    if isinstance(data, dict):
+      for key, value in data.items():
+        assert '_' not in key, f'Found snake_case key: {key} in {data}'
+        check_no_snake_case_keys(value)
+    elif isinstance(data, list):
+      for item in data:
+        check_no_snake_case_keys(item)
+
+  check_no_snake_case_keys(dumped)
+
+  # Also verify that expected keys are indeed camelCased
+  assert 'invocationId' in dumped
+  assert 'nodeInfo' in dumped
+  assert 'outputFor' in dumped['nodeInfo']
+  assert 'messageAsOutput' in dumped['nodeInfo']
+
+  # Verify RequestInput fields are camelCased
+  assert 'output' in dumped
+  assert 'interruptId' in dumped['output']
+
+
+# --- message alias for content -----------------------------------------------
+
+
+class TestMessageConstructor:
+  """Tests for Event(message=...) constructor parameter."""
+
+  def test_message_str_sets_content(self):
+    event = Event(message='Hello!')
+    assert event.content is not None
+    assert event.content.parts[0].text == 'Hello!'
+
+  def test_message_content_passes_through(self):
+    content = types.Content(
+        parts=[types.Part(text='from Content')], role='model'
+    )
+    event = Event(message=content)
+    assert event.content is content
+
+  def test_message_part_converts_to_content(self):
+    part = types.Part(text='from Part')
+    event = Event(message=part)
+    assert event.content is not None
+    assert event.content.parts[0].text == 'from Part'
+
+  def test_message_list_of_parts(self):
+    parts = [types.Part(text='part1'), types.Part(text='part2')]
+    event = Event(message=parts)
+    assert event.content is not None
+    assert len(event.content.parts) == 2
+    assert event.content.parts[0].text == 'part1'
+    assert event.content.parts[1].text == 'part2'
+
+  def test_message_and_content_raises(self):
+    with pytest.raises(ValueError, match='mutually exclusive'):
+      Event(
+          message='hello',
+          content=types.Content(parts=[types.Part(text='world')]),
+      )
+
+  def test_content_still_works(self):
+    content = types.Content(
+        parts=[types.Part(text='via content')], role='model'
+    )
+    event = Event(content=content)
+    assert event.content is content
+    assert event.content.parts[0].text == 'via content'
+
+  def test_neither_message_nor_content(self):
+    event = Event()
+    assert event.content is None
+
+
+class TestMessageProperty:
+  """Tests for Event.message property getter and setter."""
+
+  def test_message_getter_aliases_content(self):
+    content = types.Content(parts=[types.Part(text='hello')], role='model')
+    event = Event(content=content)
+    assert event.message is event.content
+
+  def test_message_getter_none_when_no_content(self):
+    event = Event()
+    assert event.message is None
+
+  def test_message_setter_updates_content(self):
+    event = Event()
+    new_content = types.Content(
+        parts=[types.Part(text='updated')], role='model'
+    )
+    event.message = new_content
+    assert event.content is new_content
+
+  def test_message_setter_accepts_str(self):
+    event = Event()
+    event.message = 'updated via setter'
+    assert event.content is not None
+    assert event.content.parts[0].text == 'updated via setter'
+
+  def test_message_setter_none_clears_content(self):
+    event = Event(message='hello')
+    event.message = None
+    assert event.content is None
+
+  def test_message_from_constructor_readable_via_property(self):
+    event = Event(message='Hello!')
+    assert event.message is not None
+    assert event.message.parts[0].text == 'Hello!'
+
+
+class TestMessageSerialization:
+  """Tests that serialization uses 'content', not 'message'."""
+
+  def test_serialized_uses_content_field(self):
+    event = Event(message='Hello!')
+    data = event.model_dump(exclude_none=True)
+    assert 'content' in data
+    assert 'message' not in data
+
+  def test_round_trip_via_content(self):
+    event = Event(message='Hello!')
+    data = event.model_dump()
+    restored = Event.model_validate(data)
+    assert restored.content is not None
+    assert restored.content.parts[0].text == 'Hello!'
+    assert restored.message is not None
+    assert restored.message.parts[0].text == 'Hello!'
+
+
+class TestMessageWithOtherKwargs:
+  """Tests message combined with other convenience kwargs."""
+
+  def test_message_with_state(self):
+    event = Event(message='hello', state={'key': 'val'})
+    assert event.content is not None
+    assert event.content.parts[0].text == 'hello'
+    assert event.actions.state_delta == {'key': 'val'}
+
+  def test_message_with_route(self):
+    event = Event(message='hello', route='next')
+    assert event.content is not None
+    assert event.actions.route == 'next'
+
+
+class TestMessageSubclassField:
+  """Tests that a subclass declaring `message` as a real field is honored.
+
+  `_accept_convenience_kwargs` already routes construction kwargs to such a
+  field; the `message` property/setter must defer to it too instead of
+  aliasing `content`.
+  """
+
+  def test_subclass_field_readable_via_property(self):
+    class _Sub(Event):
+      message: str = ''
+
+    event = _Sub(message='hello', author='a')
+    assert event.message == 'hello'
+
+  def test_subclass_field_serializes_and_round_trips(self):
+    class _Sub(Event):
+      message: str = ''
+
+    event = _Sub(message='hello', author='a')
+    data = event.model_dump()
+    assert data['message'] == 'hello'
+    assert _Sub.model_validate(data).message == 'hello'
+
+  def test_subclass_field_setter_updates_field_not_content(self):
+    class _Sub(Event):
+      message: str = ''
+
+    event = _Sub(message='hello', author='a')
+    event.message = 'updated'
+    assert event.message == 'updated'
+    assert event.content is None
+
+  def test_base_event_message_still_aliases_content(self):
+    content = types.Content(parts=[types.Part(text='hi')], role='model')
+    event = Event(content=content)
+    assert event.message is event.content