mirror of
https://github.com/microsoft/agent-framework.git
synced 2026-06-16 21:04:09 +08:00
[BREAKING] Python: Refactor SharedState to State with sync methods and superstep caching (#3667)
* Refactor SharedState to State with sync methods and superstep caching * Fixes * Address PR feedback * Remove dead links * Fix lab test import
This commit is contained in:
Evan Mattson
@@ -16,7 +16,7 @@ Coverage includes:
|
||||
- String interpolation: {Variable.Path}
|
||||
"""
|
||||
|
||||
from unittest.mock import AsyncMock, MagicMock
|
||||
from unittest.mock import MagicMock
|
||||
|
||||
import pytest
|
||||
|
||||
@@ -29,123 +29,125 @@ class TestPowerFxBuiltinFunctions:
|
||||
"""Test PowerFx built-in functions used in YAML workflows."""
|
||||
|
||||
@pytest.fixture
|
||||
def mock_shared_state(self):
|
||||
"""Create a mock shared state with async get/set methods."""
|
||||
shared_state = MagicMock()
|
||||
shared_state._data = {}
|
||||
def mock_state(self):
|
||||
"""Create a mock state with sync get/set methods."""
|
||||
state = MagicMock()
|
||||
state._data = {}
|
||||
|
||||
async def mock_get(key):
|
||||
if key not in shared_state._data:
|
||||
raise KeyError(key)
|
||||
return shared_state._data[key]
|
||||
def mock_get(key, default=None):
|
||||
return state._data.get(key, default)
|
||||
|
||||
async def mock_set(key, value):
|
||||
shared_state._data[key] = value
|
||||
def mock_set(key, value):
|
||||
state._data[key] = value
|
||||
|
||||
shared_state.get = AsyncMock(side_effect=mock_get)
|
||||
shared_state.set = AsyncMock(side_effect=mock_set)
|
||||
return shared_state
|
||||
def mock_has(key):
|
||||
return key in state._data
|
||||
|
||||
async def test_concat_simple(self, mock_shared_state):
|
||||
state.get = MagicMock(side_effect=mock_get)
|
||||
state.set = MagicMock(side_effect=mock_set)
|
||||
state.has = MagicMock(side_effect=mock_has)
|
||||
return state
|
||||
|
||||
async def test_concat_simple(self, mock_state):
|
||||
"""Test Concat function with simple strings."""
|
||||
state = DeclarativeWorkflowState(mock_shared_state)
|
||||
await state.initialize()
|
||||
state = DeclarativeWorkflowState(mock_state)
|
||||
state.initialize()
|
||||
|
||||
# From YAML: =Concat("Nice to meet you, ", Local.userName, "!")
|
||||
await state.set("Local.userName", "Alice")
|
||||
result = await state.eval('=Concat("Nice to meet you, ", Local.userName, "!")')
|
||||
state.set("Local.userName", "Alice")
|
||||
result = state.eval('=Concat("Nice to meet you, ", Local.userName, "!")')
|
||||
assert result == "Nice to meet you, Alice!"
|
||||
|
||||
async def test_concat_multiple_args(self, mock_shared_state):
|
||||
async def test_concat_multiple_args(self, mock_state):
|
||||
"""Test Concat with multiple arguments."""
|
||||
state = DeclarativeWorkflowState(mock_shared_state)
|
||||
await state.initialize()
|
||||
state = DeclarativeWorkflowState(mock_state)
|
||||
state.initialize()
|
||||
|
||||
# From YAML: =Concat(Local.greeting, ", ", Local.name, "!")
|
||||
await state.set("Local.greeting", "Hello")
|
||||
await state.set("Local.name", "World")
|
||||
result = await state.eval('=Concat(Local.greeting, ", ", Local.name, "!")')
|
||||
state.set("Local.greeting", "Hello")
|
||||
state.set("Local.name", "World")
|
||||
result = state.eval('=Concat(Local.greeting, ", ", Local.name, "!")')
|
||||
assert result == "Hello, World!"
|
||||
|
||||
async def test_concat_with_local_namespace(self, mock_shared_state):
|
||||
async def test_concat_with_local_namespace(self, mock_state):
|
||||
"""Test Concat using Local.* namespace (maps to Local.*)."""
|
||||
state = DeclarativeWorkflowState(mock_shared_state)
|
||||
await state.initialize()
|
||||
state = DeclarativeWorkflowState(mock_state)
|
||||
state.initialize()
|
||||
|
||||
# From YAML: =Concat("Starting math coaching session for: ", Local.Problem)
|
||||
await state.set("Local.Problem", "2 + 2")
|
||||
result = await state.eval('=Concat("Starting math coaching session for: ", Local.Problem)')
|
||||
state.set("Local.Problem", "2 + 2")
|
||||
result = state.eval('=Concat("Starting math coaching session for: ", Local.Problem)')
|
||||
assert result == "Starting math coaching session for: 2 + 2"
|
||||
|
||||
async def test_if_with_isblank(self, mock_shared_state):
|
||||
async def test_if_with_isblank(self, mock_state):
|
||||
"""Test If function with IsBlank."""
|
||||
state = DeclarativeWorkflowState(mock_shared_state)
|
||||
await state.initialize({"name": ""})
|
||||
state = DeclarativeWorkflowState(mock_state)
|
||||
state.initialize({"name": ""})
|
||||
|
||||
# From YAML: =If(IsBlank(inputs.name), "World", inputs.name)
|
||||
# When input is blank
|
||||
result = await state.eval('=If(IsBlank(Workflow.Inputs.name), "World", Workflow.Inputs.name)')
|
||||
result = state.eval('=If(IsBlank(Workflow.Inputs.name), "World", Workflow.Inputs.name)')
|
||||
assert result == "World"
|
||||
|
||||
# When input is provided
|
||||
await state.initialize({"name": "Alice"})
|
||||
result = await state.eval('=If(IsBlank(Workflow.Inputs.name), "World", Workflow.Inputs.name)')
|
||||
state.initialize({"name": "Alice"})
|
||||
result = state.eval('=If(IsBlank(Workflow.Inputs.name), "World", Workflow.Inputs.name)')
|
||||
assert result == "Alice"
|
||||
|
||||
async def test_not_function(self, mock_shared_state):
|
||||
async def test_not_function(self, mock_state):
|
||||
"""Test Not function."""
|
||||
state = DeclarativeWorkflowState(mock_shared_state)
|
||||
await state.initialize()
|
||||
state = DeclarativeWorkflowState(mock_state)
|
||||
state.initialize()
|
||||
|
||||
# From YAML: =Not(Local.EscalationParameters.IsComplete)
|
||||
await state.set("Local.EscalationParameters", {"IsComplete": False})
|
||||
result = await state.eval("=Not(Local.EscalationParameters.IsComplete)")
|
||||
state.set("Local.EscalationParameters", {"IsComplete": False})
|
||||
result = state.eval("=Not(Local.EscalationParameters.IsComplete)")
|
||||
assert result is True
|
||||
|
||||
await state.set("Local.EscalationParameters", {"IsComplete": True})
|
||||
result = await state.eval("=Not(Local.EscalationParameters.IsComplete)")
|
||||
state.set("Local.EscalationParameters", {"IsComplete": True})
|
||||
result = state.eval("=Not(Local.EscalationParameters.IsComplete)")
|
||||
assert result is False
|
||||
|
||||
async def test_or_function(self, mock_shared_state):
|
||||
async def test_or_function(self, mock_state):
|
||||
"""Test Or function."""
|
||||
state = DeclarativeWorkflowState(mock_shared_state)
|
||||
await state.initialize()
|
||||
state = DeclarativeWorkflowState(mock_state)
|
||||
state.initialize()
|
||||
|
||||
# From YAML: =Or(Local.feeling = "great", Local.feeling = "good")
|
||||
await state.set("Local.feeling", "great")
|
||||
result = await state.eval('=Or(Local.feeling = "great", Local.feeling = "good")')
|
||||
state.set("Local.feeling", "great")
|
||||
result = state.eval('=Or(Local.feeling = "great", Local.feeling = "good")')
|
||||
assert result is True
|
||||
|
||||
await state.set("Local.feeling", "good")
|
||||
result = await state.eval('=Or(Local.feeling = "great", Local.feeling = "good")')
|
||||
state.set("Local.feeling", "good")
|
||||
result = state.eval('=Or(Local.feeling = "great", Local.feeling = "good")')
|
||||
assert result is True
|
||||
|
||||
await state.set("Local.feeling", "bad")
|
||||
result = await state.eval('=Or(Local.feeling = "great", Local.feeling = "good")')
|
||||
state.set("Local.feeling", "bad")
|
||||
result = state.eval('=Or(Local.feeling = "great", Local.feeling = "good")')
|
||||
assert result is False
|
||||
|
||||
async def test_upper_function(self, mock_shared_state):
|
||||
async def test_upper_function(self, mock_state):
|
||||
"""Test Upper function."""
|
||||
state = DeclarativeWorkflowState(mock_shared_state)
|
||||
await state.initialize()
|
||||
state = DeclarativeWorkflowState(mock_state)
|
||||
state.initialize()
|
||||
|
||||
# From YAML: =Upper(System.LastMessage.Text)
|
||||
await state.set("System.LastMessage", {"Text": "hello world"})
|
||||
result = await state.eval("=Upper(System.LastMessage.Text)")
|
||||
state.set("System.LastMessage", {"Text": "hello world"})
|
||||
result = state.eval("=Upper(System.LastMessage.Text)")
|
||||
assert result == "HELLO WORLD"
|
||||
|
||||
async def test_find_function(self, mock_shared_state):
|
||||
async def test_find_function(self, mock_state):
|
||||
"""Test Find function."""
|
||||
state = DeclarativeWorkflowState(mock_shared_state)
|
||||
await state.initialize()
|
||||
state = DeclarativeWorkflowState(mock_state)
|
||||
state.initialize()
|
||||
|
||||
# From YAML: =!IsBlank(Find("CONGRATULATIONS", Upper(Local.TeacherResponse)))
|
||||
await state.set("Local.TeacherResponse", "CONGRATULATIONS! You solved it!")
|
||||
result = await state.eval('=Not(IsBlank(Find("CONGRATULATIONS", Upper(Local.TeacherResponse))))')
|
||||
state.set("Local.TeacherResponse", "CONGRATULATIONS! You solved it!")
|
||||
result = state.eval('=Not(IsBlank(Find("CONGRATULATIONS", Upper(Local.TeacherResponse))))')
|
||||
assert result is True
|
||||
|
||||
await state.set("Local.TeacherResponse", "Try again")
|
||||
result = await state.eval('=Not(IsBlank(Find("CONGRATULATIONS", Upper(Local.TeacherResponse))))')
|
||||
state.set("Local.TeacherResponse", "Try again")
|
||||
result = state.eval('=Not(IsBlank(Find("CONGRATULATIONS", Upper(Local.TeacherResponse))))')
|
||||
assert result is False
|
||||
|
||||
|
||||
@@ -153,55 +155,53 @@ class TestPowerFxSystemVariables:
|
||||
"""Test System.* variable access."""
|
||||
|
||||
@pytest.fixture
|
||||
def mock_shared_state(self):
|
||||
def mock_state(self):
|
||||
"""Create a mock shared state."""
|
||||
shared_state = MagicMock()
|
||||
shared_state._data = {}
|
||||
mock_state = MagicMock()
|
||||
mock_state._data = {}
|
||||
|
||||
async def mock_get(key):
|
||||
if key not in shared_state._data:
|
||||
raise KeyError(key)
|
||||
return shared_state._data[key]
|
||||
def mock_get(key, default=None):
|
||||
return mock_state._data.get(key, default)
|
||||
|
||||
async def mock_set(key, value):
|
||||
shared_state._data[key] = value
|
||||
def mock_set(key, value):
|
||||
mock_state._data[key] = value
|
||||
|
||||
shared_state.get = AsyncMock(side_effect=mock_get)
|
||||
shared_state.set = AsyncMock(side_effect=mock_set)
|
||||
return shared_state
|
||||
mock_state.get = MagicMock(side_effect=mock_get)
|
||||
mock_state.set = MagicMock(side_effect=mock_set)
|
||||
return mock_state
|
||||
|
||||
async def test_system_conversation_id(self, mock_shared_state):
|
||||
async def test_system_conversation_id(self, mock_state):
|
||||
"""Test System.ConversationId access."""
|
||||
state = DeclarativeWorkflowState(mock_shared_state)
|
||||
await state.initialize()
|
||||
state = DeclarativeWorkflowState(mock_state)
|
||||
state.initialize()
|
||||
|
||||
# From YAML: conversationId: =System.ConversationId
|
||||
await state.set("System.ConversationId", "conv-12345")
|
||||
result = await state.eval("=System.ConversationId")
|
||||
state.set("System.ConversationId", "conv-12345")
|
||||
result = state.eval("=System.ConversationId")
|
||||
assert result == "conv-12345"
|
||||
|
||||
async def test_system_last_message_text(self, mock_shared_state):
|
||||
async def test_system_last_message_text(self, mock_state):
|
||||
"""Test System.LastMessage.Text access."""
|
||||
state = DeclarativeWorkflowState(mock_shared_state)
|
||||
await state.initialize()
|
||||
state = DeclarativeWorkflowState(mock_state)
|
||||
state.initialize()
|
||||
|
||||
# From YAML: =Upper(System.LastMessage.Text) <> "EXIT"
|
||||
await state.set("System.LastMessage", {"Text": "Hello"})
|
||||
result = await state.eval("=System.LastMessage.Text")
|
||||
state.set("System.LastMessage", {"Text": "Hello"})
|
||||
result = state.eval("=System.LastMessage.Text")
|
||||
assert result == "Hello"
|
||||
|
||||
async def test_system_last_message_exit_check(self, mock_shared_state):
|
||||
async def test_system_last_message_exit_check(self, mock_state):
|
||||
"""Test the exit check pattern from YAML."""
|
||||
state = DeclarativeWorkflowState(mock_shared_state)
|
||||
await state.initialize()
|
||||
state = DeclarativeWorkflowState(mock_state)
|
||||
state.initialize()
|
||||
|
||||
# From YAML: when: =Upper(System.LastMessage.Text) <> "EXIT"
|
||||
await state.set("System.LastMessage", {"Text": "hello"})
|
||||
result = await state.eval('=Upper(System.LastMessage.Text) <> "EXIT"')
|
||||
state.set("System.LastMessage", {"Text": "hello"})
|
||||
result = state.eval('=Upper(System.LastMessage.Text) <> "EXIT"')
|
||||
assert result is True
|
||||
|
||||
await state.set("System.LastMessage", {"Text": "exit"})
|
||||
result = await state.eval('=Upper(System.LastMessage.Text) <> "EXIT"')
|
||||
state.set("System.LastMessage", {"Text": "exit"})
|
||||
result = state.eval('=Upper(System.LastMessage.Text) <> "EXIT"')
|
||||
assert result is False
|
||||
|
||||
|
||||
@@ -209,99 +209,95 @@ class TestPowerFxComparisonOperators:
|
||||
"""Test comparison operators used in YAML workflows."""
|
||||
|
||||
@pytest.fixture
|
||||
def mock_shared_state(self):
|
||||
def mock_state(self):
|
||||
"""Create a mock shared state."""
|
||||
shared_state = MagicMock()
|
||||
shared_state._data = {}
|
||||
mock_state = MagicMock()
|
||||
mock_state._data = {}
|
||||
|
||||
async def mock_get(key):
|
||||
if key not in shared_state._data:
|
||||
raise KeyError(key)
|
||||
return shared_state._data[key]
|
||||
def mock_get(key, default=None):
|
||||
return mock_state._data.get(key, default)
|
||||
|
||||
async def mock_set(key, value):
|
||||
shared_state._data[key] = value
|
||||
def mock_set(key, value):
|
||||
mock_state._data[key] = value
|
||||
|
||||
shared_state.get = AsyncMock(side_effect=mock_get)
|
||||
shared_state.set = AsyncMock(side_effect=mock_set)
|
||||
return shared_state
|
||||
mock_state.get = MagicMock(side_effect=mock_get)
|
||||
mock_state.set = MagicMock(side_effect=mock_set)
|
||||
return mock_state
|
||||
|
||||
async def test_less_than(self, mock_shared_state):
|
||||
async def test_less_than(self, mock_state):
|
||||
"""Test < operator."""
|
||||
state = DeclarativeWorkflowState(mock_shared_state)
|
||||
await state.initialize()
|
||||
state = DeclarativeWorkflowState(mock_state)
|
||||
state.initialize()
|
||||
|
||||
# From YAML: condition: =Local.age < 65
|
||||
await state.set("Local.age", 30)
|
||||
assert await state.eval("=Local.age < 65") is True
|
||||
state.set("Local.age", 30)
|
||||
assert state.eval("=Local.age < 65") is True
|
||||
|
||||
await state.set("Local.age", 70)
|
||||
assert await state.eval("=Local.age < 65") is False
|
||||
state.set("Local.age", 70)
|
||||
assert state.eval("=Local.age < 65") is False
|
||||
|
||||
async def test_less_than_with_local(self, mock_shared_state):
|
||||
async def test_less_than_with_local(self, mock_state):
|
||||
"""Test < with Local namespace."""
|
||||
state = DeclarativeWorkflowState(mock_shared_state)
|
||||
await state.initialize()
|
||||
state = DeclarativeWorkflowState(mock_state)
|
||||
state.initialize()
|
||||
|
||||
# From YAML: condition: =Local.TurnCount < 4
|
||||
await state.set("Local.TurnCount", 2)
|
||||
assert await state.eval("=Local.TurnCount < 4") is True
|
||||
state.set("Local.TurnCount", 2)
|
||||
assert state.eval("=Local.TurnCount < 4") is True
|
||||
|
||||
await state.set("Local.TurnCount", 5)
|
||||
assert await state.eval("=Local.TurnCount < 4") is False
|
||||
state.set("Local.TurnCount", 5)
|
||||
assert state.eval("=Local.TurnCount < 4") is False
|
||||
|
||||
async def test_equality(self, mock_shared_state):
|
||||
async def test_equality(self, mock_state):
|
||||
"""Test = equality operator."""
|
||||
state = DeclarativeWorkflowState(mock_shared_state)
|
||||
await state.initialize()
|
||||
state = DeclarativeWorkflowState(mock_state)
|
||||
state.initialize()
|
||||
|
||||
# From YAML: =Local.feeling = "great"
|
||||
await state.set("Local.feeling", "great")
|
||||
assert await state.eval('=Local.feeling = "great"') is True
|
||||
state.set("Local.feeling", "great")
|
||||
assert state.eval('=Local.feeling = "great"') is True
|
||||
|
||||
await state.set("Local.feeling", "bad")
|
||||
assert await state.eval('=Local.feeling = "great"') is False
|
||||
state.set("Local.feeling", "bad")
|
||||
assert state.eval('=Local.feeling = "great"') is False
|
||||
|
||||
async def test_inequality(self, mock_shared_state):
|
||||
async def test_inequality(self, mock_state):
|
||||
"""Test <> inequality operator."""
|
||||
state = DeclarativeWorkflowState(mock_shared_state)
|
||||
await state.initialize()
|
||||
state = DeclarativeWorkflowState(mock_state)
|
||||
state.initialize()
|
||||
|
||||
# From YAML: =Upper(System.LastMessage.Text) <> "EXIT"
|
||||
await state.set("Local.status", "active")
|
||||
assert await state.eval('=Local.status <> "done"') is True
|
||||
assert await state.eval('=Local.status <> "active"') is False
|
||||
state.set("Local.status", "active")
|
||||
assert state.eval('=Local.status <> "done"') is True
|
||||
assert state.eval('=Local.status <> "active"') is False
|
||||
|
||||
|
||||
class TestPowerFxArithmetic:
|
||||
"""Test arithmetic operations."""
|
||||
|
||||
@pytest.fixture
|
||||
def mock_shared_state(self):
|
||||
def mock_state(self):
|
||||
"""Create a mock shared state."""
|
||||
shared_state = MagicMock()
|
||||
shared_state._data = {}
|
||||
mock_state = MagicMock()
|
||||
mock_state._data = {}
|
||||
|
||||
async def mock_get(key):
|
||||
if key not in shared_state._data:
|
||||
raise KeyError(key)
|
||||
return shared_state._data[key]
|
||||
def mock_get(key, default=None):
|
||||
return mock_state._data.get(key, default)
|
||||
|
||||
async def mock_set(key, value):
|
||||
shared_state._data[key] = value
|
||||
def mock_set(key, value):
|
||||
mock_state._data[key] = value
|
||||
|
||||
shared_state.get = AsyncMock(side_effect=mock_get)
|
||||
shared_state.set = AsyncMock(side_effect=mock_set)
|
||||
return shared_state
|
||||
mock_state.get = MagicMock(side_effect=mock_get)
|
||||
mock_state.set = MagicMock(side_effect=mock_set)
|
||||
return mock_state
|
||||
|
||||
async def test_addition(self, mock_shared_state):
|
||||
async def test_addition(self, mock_state):
|
||||
"""Test + operator."""
|
||||
state = DeclarativeWorkflowState(mock_shared_state)
|
||||
await state.initialize()
|
||||
state = DeclarativeWorkflowState(mock_state)
|
||||
state.initialize()
|
||||
|
||||
# From YAML: value: =Local.TurnCount + 1
|
||||
await state.set("Local.TurnCount", 3)
|
||||
result = await state.eval("=Local.TurnCount + 1")
|
||||
state.set("Local.TurnCount", 3)
|
||||
result = state.eval("=Local.TurnCount + 1")
|
||||
assert result == 4
|
||||
|
||||
|
||||
@@ -309,97 +305,95 @@ class TestPowerFxCustomFunctions:
|
||||
"""Test custom functions (UserMessage, MessageText, AgentMessage)."""
|
||||
|
||||
@pytest.fixture
|
||||
def mock_shared_state(self):
|
||||
def mock_state(self):
|
||||
"""Create a mock shared state."""
|
||||
shared_state = MagicMock()
|
||||
shared_state._data = {}
|
||||
mock_state = MagicMock()
|
||||
mock_state._data = {}
|
||||
|
||||
async def mock_get(key):
|
||||
if key not in shared_state._data:
|
||||
raise KeyError(key)
|
||||
return shared_state._data[key]
|
||||
def mock_get(key, default=None):
|
||||
return mock_state._data.get(key, default)
|
||||
|
||||
async def mock_set(key, value):
|
||||
shared_state._data[key] = value
|
||||
def mock_set(key, value):
|
||||
mock_state._data[key] = value
|
||||
|
||||
shared_state.get = AsyncMock(side_effect=mock_get)
|
||||
shared_state.set = AsyncMock(side_effect=mock_set)
|
||||
return shared_state
|
||||
mock_state.get = MagicMock(side_effect=mock_get)
|
||||
mock_state.set = MagicMock(side_effect=mock_set)
|
||||
return mock_state
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_agent_message_function(self, mock_shared_state):
|
||||
async def test_agent_message_function(self, mock_state):
|
||||
"""Test AgentMessage function (.NET compatibility alias for AssistantMessage)."""
|
||||
state = DeclarativeWorkflowState(mock_shared_state)
|
||||
await state.initialize()
|
||||
state = DeclarativeWorkflowState(mock_state)
|
||||
state.initialize()
|
||||
|
||||
# From .NET YAML: messages: =AgentMessage(Local.Response)
|
||||
await state.set("Local.Response", "Here is the analysis result")
|
||||
result = await state.eval("=AgentMessage(Local.Response)")
|
||||
state.set("Local.Response", "Here is the analysis result")
|
||||
result = state.eval("=AgentMessage(Local.Response)")
|
||||
|
||||
assert isinstance(result, dict)
|
||||
assert result["role"] == "assistant"
|
||||
assert result["text"] == "Here is the analysis result"
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_agent_message_with_empty_string(self, mock_shared_state):
|
||||
async def test_agent_message_with_empty_string(self, mock_state):
|
||||
"""Test AgentMessage with empty string."""
|
||||
state = DeclarativeWorkflowState(mock_shared_state)
|
||||
await state.initialize()
|
||||
state = DeclarativeWorkflowState(mock_state)
|
||||
state.initialize()
|
||||
|
||||
await state.set("Local.Response", "")
|
||||
result = await state.eval("=AgentMessage(Local.Response)")
|
||||
state.set("Local.Response", "")
|
||||
result = state.eval("=AgentMessage(Local.Response)")
|
||||
|
||||
assert result["role"] == "assistant"
|
||||
assert result["text"] == ""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_user_message_with_variable(self, mock_shared_state):
|
||||
async def test_user_message_with_variable(self, mock_state):
|
||||
"""Test UserMessage function with variable reference."""
|
||||
state = DeclarativeWorkflowState(mock_shared_state)
|
||||
await state.initialize()
|
||||
state = DeclarativeWorkflowState(mock_state)
|
||||
state.initialize()
|
||||
|
||||
# From YAML: messages: =UserMessage(Local.ServiceParameters.IssueDescription)
|
||||
await state.set("Local.ServiceParameters", {"IssueDescription": "My computer won't boot"})
|
||||
result = await state.eval("=UserMessage(Local.ServiceParameters.IssueDescription)")
|
||||
state.set("Local.ServiceParameters", {"IssueDescription": "My computer won't boot"})
|
||||
result = state.eval("=UserMessage(Local.ServiceParameters.IssueDescription)")
|
||||
|
||||
assert isinstance(result, dict)
|
||||
assert result["role"] == "user"
|
||||
assert result["text"] == "My computer won't boot"
|
||||
|
||||
async def test_user_message_with_simple_variable(self, mock_shared_state):
|
||||
async def test_user_message_with_simple_variable(self, mock_state):
|
||||
"""Test UserMessage with simple variable."""
|
||||
state = DeclarativeWorkflowState(mock_shared_state)
|
||||
await state.initialize()
|
||||
state = DeclarativeWorkflowState(mock_state)
|
||||
state.initialize()
|
||||
|
||||
# From YAML: messages: =Local.Problem
|
||||
await state.set("Local.Problem", "What is 2+2?")
|
||||
result = await state.eval("=UserMessage(Local.Problem)")
|
||||
state.set("Local.Problem", "What is 2+2?")
|
||||
result = state.eval("=UserMessage(Local.Problem)")
|
||||
|
||||
assert result["role"] == "user"
|
||||
assert result["text"] == "What is 2+2?"
|
||||
|
||||
async def test_message_text_with_list(self, mock_shared_state):
|
||||
async def test_message_text_with_list(self, mock_state):
|
||||
"""Test MessageText extracts text from message list."""
|
||||
state = DeclarativeWorkflowState(mock_shared_state)
|
||||
await state.initialize()
|
||||
state = DeclarativeWorkflowState(mock_state)
|
||||
state.initialize()
|
||||
|
||||
await state.set(
|
||||
state.set(
|
||||
"Local.messages",
|
||||
[
|
||||
{"role": "user", "text": "Hello"},
|
||||
{"role": "assistant", "text": "Hi there!"},
|
||||
],
|
||||
)
|
||||
result = await state.eval("=MessageText(Local.messages)")
|
||||
result = state.eval("=MessageText(Local.messages)")
|
||||
assert result == "Hi there!"
|
||||
|
||||
async def test_message_text_empty_list(self, mock_shared_state):
|
||||
async def test_message_text_empty_list(self, mock_state):
|
||||
"""Test MessageText with empty list returns empty string."""
|
||||
state = DeclarativeWorkflowState(mock_shared_state)
|
||||
await state.initialize()
|
||||
state = DeclarativeWorkflowState(mock_state)
|
||||
state.initialize()
|
||||
|
||||
await state.set("Local.messages", [])
|
||||
result = await state.eval("=MessageText(Local.messages)")
|
||||
state.set("Local.messages", [])
|
||||
result = state.eval("=MessageText(Local.messages)")
|
||||
assert result == ""
|
||||
|
||||
|
||||
@@ -407,51 +401,49 @@ class TestPowerFxNestedVariables:
|
||||
"""Test nested variable access patterns from YAML."""
|
||||
|
||||
@pytest.fixture
|
||||
def mock_shared_state(self):
|
||||
def mock_state(self):
|
||||
"""Create a mock shared state."""
|
||||
shared_state = MagicMock()
|
||||
shared_state._data = {}
|
||||
mock_state = MagicMock()
|
||||
mock_state._data = {}
|
||||
|
||||
async def mock_get(key):
|
||||
if key not in shared_state._data:
|
||||
raise KeyError(key)
|
||||
return shared_state._data[key]
|
||||
def mock_get(key, default=None):
|
||||
return mock_state._data.get(key, default)
|
||||
|
||||
async def mock_set(key, value):
|
||||
shared_state._data[key] = value
|
||||
def mock_set(key, value):
|
||||
mock_state._data[key] = value
|
||||
|
||||
shared_state.get = AsyncMock(side_effect=mock_get)
|
||||
shared_state.set = AsyncMock(side_effect=mock_set)
|
||||
return shared_state
|
||||
mock_state.get = MagicMock(side_effect=mock_get)
|
||||
mock_state.set = MagicMock(side_effect=mock_set)
|
||||
return mock_state
|
||||
|
||||
async def test_nested_local_variable(self, mock_shared_state):
|
||||
async def test_nested_local_variable(self, mock_state):
|
||||
"""Test nested Local.* variable access."""
|
||||
state = DeclarativeWorkflowState(mock_shared_state)
|
||||
await state.initialize()
|
||||
state = DeclarativeWorkflowState(mock_state)
|
||||
state.initialize()
|
||||
|
||||
# From YAML: =Local.ServiceParameters.IssueDescription
|
||||
await state.set("Local.ServiceParameters", {"IssueDescription": "Screen is black"})
|
||||
result = await state.eval("=Local.ServiceParameters.IssueDescription")
|
||||
state.set("Local.ServiceParameters", {"IssueDescription": "Screen is black"})
|
||||
result = state.eval("=Local.ServiceParameters.IssueDescription")
|
||||
assert result == "Screen is black"
|
||||
|
||||
async def test_nested_routing_parameters(self, mock_shared_state):
|
||||
async def test_nested_routing_parameters(self, mock_state):
|
||||
"""Test RoutingParameters access."""
|
||||
state = DeclarativeWorkflowState(mock_shared_state)
|
||||
await state.initialize()
|
||||
state = DeclarativeWorkflowState(mock_state)
|
||||
state.initialize()
|
||||
|
||||
# From YAML: =Local.RoutingParameters.TeamName
|
||||
await state.set("Local.RoutingParameters", {"TeamName": "Windows Support"})
|
||||
result = await state.eval("=Local.RoutingParameters.TeamName")
|
||||
state.set("Local.RoutingParameters", {"TeamName": "Windows Support"})
|
||||
result = state.eval("=Local.RoutingParameters.TeamName")
|
||||
assert result == "Windows Support"
|
||||
|
||||
async def test_nested_ticket_parameters(self, mock_shared_state):
|
||||
async def test_nested_ticket_parameters(self, mock_state):
|
||||
"""Test TicketParameters access."""
|
||||
state = DeclarativeWorkflowState(mock_shared_state)
|
||||
await state.initialize()
|
||||
state = DeclarativeWorkflowState(mock_state)
|
||||
state.initialize()
|
||||
|
||||
# From YAML: =Local.TicketParameters.TicketId
|
||||
await state.set("Local.TicketParameters", {"TicketId": "TKT-12345"})
|
||||
result = await state.eval("=Local.TicketParameters.TicketId")
|
||||
state.set("Local.TicketParameters", {"TicketId": "TKT-12345"})
|
||||
result = state.eval("=Local.TicketParameters.TicketId")
|
||||
assert result == "TKT-12345"
|
||||
|
||||
|
||||
@@ -459,39 +451,37 @@ class TestPowerFxUndefinedVariables:
|
||||
"""Test graceful handling of undefined variables."""
|
||||
|
||||
@pytest.fixture
|
||||
def mock_shared_state(self):
|
||||
def mock_state(self):
|
||||
"""Create a mock shared state."""
|
||||
shared_state = MagicMock()
|
||||
shared_state._data = {}
|
||||
mock_state = MagicMock()
|
||||
mock_state._data = {}
|
||||
|
||||
async def mock_get(key):
|
||||
if key not in shared_state._data:
|
||||
raise KeyError(key)
|
||||
return shared_state._data[key]
|
||||
def mock_get(key, default=None):
|
||||
return mock_state._data.get(key, default)
|
||||
|
||||
async def mock_set(key, value):
|
||||
shared_state._data[key] = value
|
||||
def mock_set(key, value):
|
||||
mock_state._data[key] = value
|
||||
|
||||
shared_state.get = AsyncMock(side_effect=mock_get)
|
||||
shared_state.set = AsyncMock(side_effect=mock_set)
|
||||
return shared_state
|
||||
mock_state.get = MagicMock(side_effect=mock_get)
|
||||
mock_state.set = MagicMock(side_effect=mock_set)
|
||||
return mock_state
|
||||
|
||||
async def test_undefined_local_variable_returns_none(self, mock_shared_state):
|
||||
async def test_undefined_local_variable_returns_none(self, mock_state):
|
||||
"""Test that undefined Local.* variables return None."""
|
||||
state = DeclarativeWorkflowState(mock_shared_state)
|
||||
await state.initialize()
|
||||
state = DeclarativeWorkflowState(mock_state)
|
||||
state.initialize()
|
||||
|
||||
# Variable not set - should return None (not raise)
|
||||
result = await state.eval("=Local.UndefinedVariable")
|
||||
result = state.eval("=Local.UndefinedVariable")
|
||||
assert result is None
|
||||
|
||||
async def test_undefined_nested_variable_returns_none(self, mock_shared_state):
|
||||
async def test_undefined_nested_variable_returns_none(self, mock_state):
|
||||
"""Test that undefined nested variables return None."""
|
||||
state = DeclarativeWorkflowState(mock_shared_state)
|
||||
await state.initialize()
|
||||
state = DeclarativeWorkflowState(mock_state)
|
||||
state.initialize()
|
||||
|
||||
# Nested undefined variable
|
||||
result = await state.eval("=Local.Something.Nested.Deep")
|
||||
result = state.eval("=Local.Something.Nested.Deep")
|
||||
assert result is None
|
||||
|
||||
|
||||
@@ -499,41 +489,39 @@ class TestStringInterpolation:
|
||||
"""Test string interpolation patterns."""
|
||||
|
||||
@pytest.fixture
|
||||
def mock_shared_state(self):
|
||||
def mock_state(self):
|
||||
"""Create a mock shared state."""
|
||||
shared_state = MagicMock()
|
||||
shared_state._data = {}
|
||||
mock_state = MagicMock()
|
||||
mock_state._data = {}
|
||||
|
||||
async def mock_get(key):
|
||||
if key not in shared_state._data:
|
||||
raise KeyError(key)
|
||||
return shared_state._data[key]
|
||||
def mock_get(key, default=None):
|
||||
return mock_state._data.get(key, default)
|
||||
|
||||
async def mock_set(key, value):
|
||||
shared_state._data[key] = value
|
||||
def mock_set(key, value):
|
||||
mock_state._data[key] = value
|
||||
|
||||
shared_state.get = AsyncMock(side_effect=mock_get)
|
||||
shared_state.set = AsyncMock(side_effect=mock_set)
|
||||
return shared_state
|
||||
mock_state.get = MagicMock(side_effect=mock_get)
|
||||
mock_state.set = MagicMock(side_effect=mock_set)
|
||||
return mock_state
|
||||
|
||||
async def test_interpolate_local_variable(self, mock_shared_state):
|
||||
async def test_interpolate_local_variable(self, mock_state):
|
||||
"""Test {Local.Variable} interpolation."""
|
||||
state = DeclarativeWorkflowState(mock_shared_state)
|
||||
await state.initialize()
|
||||
state = DeclarativeWorkflowState(mock_state)
|
||||
state.initialize()
|
||||
|
||||
# From YAML: activity: "Created ticket #{Local.TicketParameters.TicketId}"
|
||||
await state.set("Local.TicketParameters", {"TicketId": "TKT-999"})
|
||||
result = await state.interpolate_string("Created ticket #{Local.TicketParameters.TicketId}")
|
||||
state.set("Local.TicketParameters", {"TicketId": "TKT-999"})
|
||||
result = state.interpolate_string("Created ticket #{Local.TicketParameters.TicketId}")
|
||||
assert result == "Created ticket #TKT-999"
|
||||
|
||||
async def test_interpolate_routing_team(self, mock_shared_state):
|
||||
async def test_interpolate_routing_team(self, mock_state):
|
||||
"""Test routing team interpolation."""
|
||||
state = DeclarativeWorkflowState(mock_shared_state)
|
||||
await state.initialize()
|
||||
state = DeclarativeWorkflowState(mock_state)
|
||||
state.initialize()
|
||||
|
||||
# From YAML: activity: Routing to {Local.RoutingParameters.TeamName}
|
||||
await state.set("Local.RoutingParameters", {"TeamName": "Linux Support"})
|
||||
result = await state.interpolate_string("Routing to {Local.RoutingParameters.TeamName}")
|
||||
state.set("Local.RoutingParameters", {"TeamName": "Linux Support"})
|
||||
result = state.interpolate_string("Routing to {Local.RoutingParameters.TeamName}")
|
||||
assert result == "Routing to Linux Support"
|
||||
|
||||
|
||||
@@ -541,41 +529,39 @@ class TestWorkflowInputsAccess:
|
||||
"""Test Workflow.Inputs access patterns."""
|
||||
|
||||
@pytest.fixture
|
||||
def mock_shared_state(self):
|
||||
def mock_state(self):
|
||||
"""Create a mock shared state."""
|
||||
shared_state = MagicMock()
|
||||
shared_state._data = {}
|
||||
mock_state = MagicMock()
|
||||
mock_state._data = {}
|
||||
|
||||
async def mock_get(key):
|
||||
if key not in shared_state._data:
|
||||
raise KeyError(key)
|
||||
return shared_state._data[key]
|
||||
def mock_get(key, default=None):
|
||||
return mock_state._data.get(key, default)
|
||||
|
||||
async def mock_set(key, value):
|
||||
shared_state._data[key] = value
|
||||
def mock_set(key, value):
|
||||
mock_state._data[key] = value
|
||||
|
||||
shared_state.get = AsyncMock(side_effect=mock_get)
|
||||
shared_state.set = AsyncMock(side_effect=mock_set)
|
||||
return shared_state
|
||||
mock_state.get = MagicMock(side_effect=mock_get)
|
||||
mock_state.set = MagicMock(side_effect=mock_set)
|
||||
return mock_state
|
||||
|
||||
async def test_inputs_name(self, mock_shared_state):
|
||||
async def test_inputs_name(self, mock_state):
|
||||
"""Test inputs.name access."""
|
||||
state = DeclarativeWorkflowState(mock_shared_state)
|
||||
await state.initialize({"name": "Alice", "age": 25})
|
||||
state = DeclarativeWorkflowState(mock_state)
|
||||
state.initialize({"name": "Alice", "age": 25})
|
||||
|
||||
# .NET style (standard)
|
||||
result = await state.eval("=Workflow.Inputs.name")
|
||||
result = state.eval("=Workflow.Inputs.name")
|
||||
assert result == "Alice"
|
||||
|
||||
# Also test inputs.name shorthand
|
||||
result = await state.eval("=inputs.name")
|
||||
result = state.eval("=inputs.name")
|
||||
assert result == "Alice"
|
||||
|
||||
async def test_inputs_problem(self, mock_shared_state):
|
||||
async def test_inputs_problem(self, mock_state):
|
||||
"""Test inputs.problem access."""
|
||||
state = DeclarativeWorkflowState(mock_shared_state)
|
||||
await state.initialize({"problem": "What is 5 * 6?"})
|
||||
state = DeclarativeWorkflowState(mock_state)
|
||||
state.initialize({"problem": "What is 5 * 6?"})
|
||||
|
||||
# .NET style (standard)
|
||||
result = await state.eval("=Workflow.Inputs.problem")
|
||||
result = state.eval("=Workflow.Inputs.problem")
|
||||
assert result == "What is 5 * 6?"
|
||||
|
||||
Reference in New Issue
Block a user