1006 lines
35 KiB
Python
1006 lines
35 KiB
Python
# Copyright 2026 Google LLC
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
|
|
import json
|
|
from unittest.mock import AsyncMock, MagicMock, Mock, patch
|
|
from langchain_core.messages import AIMessage
|
|
from artemis.agents.validator.failure_analyzer import ValidationErrorCategory
|
|
from artemis.agents.validator.validator import ValidatorNode
|
|
from artemis.context import ArtemisContext
|
|
import pytest
|
|
|
|
|
|
class DummyState:
|
|
def __init__(
|
|
self,
|
|
structured_decisions,
|
|
validator_messages=[],
|
|
current_step_id=None,
|
|
latest_screenshot=None,
|
|
):
|
|
self.structured_decisions = structured_decisions
|
|
self.validator_messages = validator_messages
|
|
self.current_step_id = current_step_id
|
|
self.latest_screenshot = latest_screenshot
|
|
|
|
async def asanitize_update(self, ctx, update, agent):
|
|
return update
|
|
|
|
|
|
@pytest.fixture
|
|
def mock_context(tmp_path):
|
|
ctx = Mock(spec=ArtemisContext)
|
|
ctx.llm_config = Mock()
|
|
ctx.data_engine = Mock()
|
|
ctx.data_engine.base_dir = tmp_path
|
|
ctx.data_engine.get_relative_time.return_value = 1.0
|
|
return ctx
|
|
|
|
|
|
@pytest.fixture
|
|
def temp_screenshot(tmp_path):
|
|
p = tmp_path / "screenshot.png"
|
|
p.write_bytes(b"dummy_data")
|
|
return str(p)
|
|
|
|
|
|
@pytest.fixture
|
|
def mock_mcp():
|
|
with (
|
|
patch("mcp.client.stdio.stdio_client") as mock_stdio,
|
|
patch("artemis.agents.validator.validator.ClientSession") as mock_session_cls,
|
|
):
|
|
mock_ctx = AsyncMock()
|
|
mock_ctx.__aenter__.return_value = (Mock(), Mock())
|
|
mock_stdio.return_value = mock_ctx
|
|
|
|
mock_session = AsyncMock()
|
|
mock_session.initialize = AsyncMock()
|
|
mock_session_cls.return_value = mock_session
|
|
|
|
yield mock_session
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_validator_success(mock_mcp, mock_context, temp_screenshot):
|
|
"""Test that ValidatorNode executes actions successfully."""
|
|
# Mock MCP calls: screenshot, tap, screenshot
|
|
mock_mcp.call_tool.side_effect = [
|
|
Mock(content=[Mock(text="ZHVtbXlfZGF0YQ==")]), # pre-screenshot
|
|
Mock(content=[Mock(text="Success")]), # tap action
|
|
Mock(content=[Mock(text="ZHVtbXlfZGF0YQ==")]), # post-screenshot
|
|
]
|
|
|
|
decisions = json.dumps([{"action": "tap", "coordinates": [105, 205]}])
|
|
state = DummyState(structured_decisions=decisions, latest_screenshot=temp_screenshot)
|
|
|
|
with patch("artemis.utils.image_diff.check_ui_change", return_value=True):
|
|
node = ValidatorNode(mock_context)
|
|
result = await node(state)
|
|
|
|
assert "last_execution_result" in result
|
|
report = result["last_execution_result"]
|
|
assert "execution" in report
|
|
assert len(report["execution"]) == 1
|
|
assert report["execution"][0]["action"] == "tap"
|
|
assert "attempts" not in report["execution"][0]
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_failed_mcp_handshake_exits_contexts_and_disables_child_awake_policy():
|
|
"""A handshake failure must not leave AnyIO cancellation scopes behind."""
|
|
events = []
|
|
|
|
class FakeClientContext:
|
|
async def __aenter__(self):
|
|
events.append("client_enter")
|
|
return Mock(), Mock()
|
|
|
|
async def __aexit__(self, exc_type, exc, traceback):
|
|
events.append("client_exit")
|
|
|
|
class FakeSession:
|
|
async def __aenter__(self):
|
|
events.append("session_enter")
|
|
return self
|
|
|
|
async def __aexit__(self, exc_type, exc, traceback):
|
|
events.append("session_exit")
|
|
|
|
async def initialize(self):
|
|
raise TimeoutError("handshake timed out")
|
|
|
|
ctx = Mock(spec=ArtemisContext)
|
|
ctx.mcp_client_ctx = None
|
|
ctx.mcp_session = None
|
|
fake_client_ctx = FakeClientContext()
|
|
fake_session = FakeSession()
|
|
captured_parameters = []
|
|
|
|
def fake_stdio_client(parameters):
|
|
captured_parameters.append(parameters)
|
|
return fake_client_ctx
|
|
|
|
node = ValidatorNode(ctx)
|
|
with (
|
|
patch("artemis.agents.validator.validator.stdio_client", fake_stdio_client),
|
|
patch("artemis.agents.validator.validator.ClientSession", return_value=fake_session),
|
|
patch("artemis.agents.validator.validator.AdbClient") as adb_client,
|
|
patch.object(node, "_kill_mcp_server_instantly") as emergency_kill,
|
|
):
|
|
adb_client.return_value.device_list.return_value = []
|
|
result = await node._get_mcp_session()
|
|
|
|
assert result is None
|
|
assert events == ["client_enter", "session_enter", "session_exit", "client_exit"]
|
|
assert ctx.mcp_session is None
|
|
assert ctx.mcp_client_ctx is None
|
|
assert captured_parameters[0].env["ARTEMIS_KEEP_DEVICE_AWAKE"] == "false"
|
|
emergency_kill.assert_not_called()
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_validator_failure_analysis(mock_mcp, mock_context, temp_screenshot):
|
|
"""Test that ValidatorNode triggers failure analysis on error and handles
|
|
cannot_fix via tool.
|
|
"""
|
|
tap_count = 0
|
|
|
|
def mock_call_tool(name, args):
|
|
nonlocal tap_count
|
|
if name == "take_screenshot":
|
|
return Mock(content=[Mock(text="ZHVtbXlfZGF0YQ==")])
|
|
if name == "tap":
|
|
tap_count += 1
|
|
return Mock(content=[Mock(text="Error: Element not found")])
|
|
return Mock(content=[Mock(text="Success")])
|
|
|
|
mock_mcp.call_tool.side_effect = mock_call_tool
|
|
|
|
decisions = json.dumps([{"action": "tap", "coordinates": [105, 205]}])
|
|
state = DummyState(structured_decisions=decisions, latest_screenshot=temp_screenshot)
|
|
|
|
node = ValidatorNode(mock_context)
|
|
|
|
with (
|
|
patch("artemis.agents.validator.failure_analyzer.FailureAnalyzer.analyze") as mock_analyze,
|
|
patch("artemis.utils.image_diff.check_ui_change", return_value=False),
|
|
):
|
|
mock_analyze.return_value = {
|
|
"status": "cannot_fix",
|
|
"analysis": "Analysis: Coordinates are likely wrong.",
|
|
}
|
|
|
|
result = await node(state)
|
|
|
|
assert "last_execution_result" in result
|
|
report = result["last_execution_result"]
|
|
assert "execution" in report
|
|
assert len(report["execution"]) == 1
|
|
assert report["execution"][0]["action"] == "tap"
|
|
assert report["execution"][0]["attempts"] == [
|
|
"Error: Element not found",
|
|
"Error: Element not found",
|
|
]
|
|
assert report["execution"][0]["repair"] == "Analysis: Coordinates are likely wrong."
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_validator_repair_success(mock_mcp, mock_context, temp_screenshot):
|
|
"""Test that ValidatorNode terminates successfully and clears remaining actions
|
|
after successful repair.
|
|
"""
|
|
tap_count = 0
|
|
|
|
def mock_call_tool(name, args):
|
|
nonlocal tap_count
|
|
if name == "take_screenshot":
|
|
return Mock(content=[Mock(text="ZHVtbXlfZGF0YQ==")])
|
|
if name == "tap":
|
|
tap_count += 1
|
|
if tap_count <= 2: # First tap fails
|
|
return Mock(content=[Mock(text="Error: Element not found")])
|
|
return Mock(content=[Mock(text="Success")])
|
|
return Mock(content=[Mock(text="Success")])
|
|
|
|
mock_mcp.call_tool.side_effect = mock_call_tool
|
|
|
|
# Two actions planned initially
|
|
decisions = json.dumps(
|
|
[
|
|
{"action": "tap", "coordinates": [105, 205]},
|
|
{"action": "tap", "coordinates": [205, 305]},
|
|
]
|
|
)
|
|
state = DummyState(structured_decisions=decisions, latest_screenshot=temp_screenshot)
|
|
|
|
node = ValidatorNode(mock_context)
|
|
|
|
with (
|
|
patch("artemis.agents.validator.failure_analyzer.FailureAnalyzer.analyze") as mock_analyze,
|
|
patch("artemis.utils.image_diff.check_ui_change", return_value=False),
|
|
):
|
|
mock_analyze.return_value = {
|
|
"status": "fixed",
|
|
"analysis": "Fixed by updating actions",
|
|
}
|
|
|
|
result = await node(state)
|
|
|
|
assert "last_execution_result" in result
|
|
report = result["last_execution_result"]
|
|
assert "execution" in report
|
|
assert len(report["execution"]) == 1 # Only the first failed action is in report
|
|
|
|
assert report["execution"][0]["coordinates"] == [105, 205]
|
|
assert report["execution"][0]["attempts"] == [
|
|
"Error: Element not found",
|
|
"Error: Element not found",
|
|
]
|
|
assert report["execution"][0]["repair"] == "Fixed by updating actions"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_validator_wait_for_delay(mock_mcp, mock_context, temp_screenshot):
|
|
"""Test that wait_for_delay executes successfully."""
|
|
|
|
def mock_call(name, args):
|
|
return Mock(content=[Mock(text="ZHVtbXlfZGF0YQ==")])
|
|
|
|
mock_mcp.call_tool.side_effect = mock_call
|
|
|
|
decisions = json.dumps([{"action": "wait_for_delay", "time_in_ms": 10}])
|
|
state = DummyState(structured_decisions=decisions, latest_screenshot=temp_screenshot)
|
|
|
|
with patch("artemis.utils.image_diff.check_ui_change", return_value=False):
|
|
node = ValidatorNode(mock_context)
|
|
result = await node(state)
|
|
|
|
assert "last_execution_result" in result
|
|
report = result["last_execution_result"]
|
|
assert "execution" in report
|
|
assert len(report["execution"]) == 1
|
|
assert report["execution"][0]["action"] == "wait_for_delay"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_validator_focus_and_clear_text_no_ui_change(mock_mcp, mock_context, temp_screenshot):
|
|
"""Test that focus_and_clear_text executes successfully even if no UI change is detected."""
|
|
|
|
def mock_call(name, args):
|
|
if name == "focus_and_clear_text":
|
|
return Mock(content=[Mock(text="Success")])
|
|
return Mock(content=[Mock(text="ZHVtbXlfZGF0YQ==")])
|
|
|
|
mock_mcp.call_tool.side_effect = mock_call
|
|
|
|
decisions = json.dumps([{"action": "focus_and_clear_text", "coordinates": [400, 500]}])
|
|
state = DummyState(structured_decisions=decisions, latest_screenshot=temp_screenshot)
|
|
|
|
with patch("artemis.utils.image_diff.check_ui_change", return_value=False):
|
|
node = ValidatorNode(mock_context)
|
|
result = await node(state)
|
|
|
|
assert "last_execution_result" in result
|
|
report = result["last_execution_result"]
|
|
assert "execution" in report
|
|
assert len(report["execution"]) == 1
|
|
assert report["execution"][0]["action"] == "focus_and_clear_text"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_validator_silent_failure_treated_as_success(mock_mcp, mock_context, temp_screenshot):
|
|
"""Test that silent failure (exec succeeds but no UI change) is treated as
|
|
success and does not trigger FailureAnalyzer.
|
|
"""
|
|
|
|
def mock_call_tool(name, args):
|
|
if name == "take_screenshot":
|
|
return Mock(content=[Mock(text="ZHVtbXlfZGF0YQ==")])
|
|
if name == "tap":
|
|
return Mock(content=[Mock(text="Success")])
|
|
return Mock(content=[Mock(text="Success")])
|
|
|
|
mock_mcp.call_tool.side_effect = mock_call_tool
|
|
|
|
decisions = json.dumps([{"action": "tap", "coordinates": [105, 205]}])
|
|
state = DummyState(structured_decisions=decisions, latest_screenshot=temp_screenshot)
|
|
|
|
node = ValidatorNode(mock_context)
|
|
|
|
with (
|
|
patch("artemis.agents.validator.validator.VALIDATOR_POLL_TIMEOUT", 0.1),
|
|
patch("artemis.agents.validator.validator.VALIDATOR_POLL_INTERVAL", 0.01),
|
|
patch("artemis.agents.validator.failure_analyzer.FailureAnalyzer.analyze") as mock_analyze,
|
|
patch("artemis.utils.image_diff.check_ui_change", return_value=False), # No UI change
|
|
):
|
|
result = await node(state)
|
|
|
|
# Assert FailureAnalyzer was NOT called
|
|
mock_analyze.assert_not_called()
|
|
|
|
# Assert the action is considered executed successfully
|
|
assert "last_execution_result" in result
|
|
report = result["last_execution_result"]
|
|
assert "execution" in report
|
|
assert len(report["execution"]) == 1
|
|
assert report["execution"][0]["action"] == "tap"
|
|
assert "attempts" not in report["execution"][0]
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_validator_records_skipped_actions_on_cannot_fix(
|
|
mock_mcp, mock_context, temp_screenshot
|
|
):
|
|
"""Test that ValidatorNode marks unexecuted actions as Skipped when repair fails."""
|
|
|
|
def mock_call_tool(name, args):
|
|
if name == "take_screenshot":
|
|
return Mock(content=[Mock(text="ZHVtbXlfZGF0YQ==")])
|
|
return Mock(content=[Mock(text="Error: Connection lost")])
|
|
|
|
mock_mcp.call_tool.side_effect = mock_call_tool
|
|
|
|
# Two actions planned
|
|
decisions = json.dumps(
|
|
[
|
|
{"action": "tap", "coordinates": [100, 200]},
|
|
{"action": "press_key", "keycode": "ENTER"},
|
|
]
|
|
)
|
|
state = DummyState(structured_decisions=decisions, latest_screenshot=temp_screenshot)
|
|
|
|
node = ValidatorNode(mock_context)
|
|
|
|
with (
|
|
patch("artemis.agents.validator.failure_analyzer.FailureAnalyzer.analyze") as mock_analyze,
|
|
patch("artemis.utils.image_diff.check_ui_change", return_value=False),
|
|
):
|
|
mock_analyze.return_value = {
|
|
"status": "cannot_fix",
|
|
"analysis": "Cannot fix: System crashed.",
|
|
}
|
|
|
|
result = await node(state)
|
|
|
|
assert "last_execution_result" in result
|
|
report = result["last_execution_result"]
|
|
assert "execution" in report
|
|
assert len(report["execution"]) == 2
|
|
|
|
# First action failed
|
|
assert report["execution"][0]["action"] == "tap"
|
|
assert report["execution"][0]["attempts"] == [
|
|
"Error: Connection lost",
|
|
"Error: Connection lost",
|
|
]
|
|
assert report["execution"][0]["repair"] == "Cannot fix: System crashed."
|
|
|
|
# Second action was skipped
|
|
assert report["execution"][1]["action"] == "press_key"
|
|
assert report["execution"][1]["attempts"] == ["Skipped"]
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_validator_pre_execution_validation_and_repair(
|
|
mock_mcp, mock_context, temp_screenshot
|
|
):
|
|
"""Test that pre-execution validation fails when element changes, and is
|
|
repaired by FailureAnalyzer.
|
|
"""
|
|
mock_live_elements = [
|
|
{
|
|
"text": "Sign Up",
|
|
"bounds": "[100,200][300,300]",
|
|
"resource-id": "btn_signup",
|
|
}
|
|
]
|
|
|
|
def mock_call_tool(name, args):
|
|
if name == "take_screenshot":
|
|
return Mock(content=[Mock(text="ZHVtbXlfZGF0YQ==")])
|
|
if name == "get_ui_hierarchy":
|
|
return Mock(content=[Mock(text=json.dumps(mock_live_elements))])
|
|
if name == "tap":
|
|
return Mock(content=[Mock(text="Success")])
|
|
return Mock(content=[Mock(text="Success")])
|
|
|
|
mock_mcp.call_tool.side_effect = mock_call_tool
|
|
|
|
decisions = json.dumps(
|
|
[
|
|
{
|
|
"action": "tap",
|
|
"coordinates": [200, 250],
|
|
"target_text": "Login",
|
|
"target_bounds": [100, 200, 300, 300],
|
|
"target_resource_id": "btn_login",
|
|
}
|
|
]
|
|
)
|
|
|
|
state = DummyState(structured_decisions=decisions, latest_screenshot=temp_screenshot)
|
|
node = ValidatorNode(mock_context)
|
|
|
|
with (
|
|
patch("artemis.agents.validator.failure_analyzer.FailureAnalyzer.analyze") as mock_analyze,
|
|
patch("artemis.utils.image_diff.check_ui_change", return_value=True),
|
|
patch.object(
|
|
ValidatorNode,
|
|
"_validate_action_precondition_pixel",
|
|
new_callable=AsyncMock,
|
|
) as mock_pixel,
|
|
):
|
|
mock_pixel.return_value = (
|
|
False,
|
|
ValidationErrorCategory.PIXEL_TARGET_DISAPPEARED,
|
|
"Pixel check failed",
|
|
)
|
|
mock_analyze.return_value = {
|
|
"status": "fixed",
|
|
"analysis": ("Pre-exec failure matched and resolved by switching to Sign Up button."),
|
|
}
|
|
|
|
result = await node(state)
|
|
|
|
mock_analyze.assert_called_once()
|
|
args, kwargs = mock_analyze.call_args
|
|
assert "Pre-execution validation failed" in args[2]
|
|
assert "Login" in args[2]
|
|
assert kwargs.get("error_category") == ValidationErrorCategory.TARGET_OCCUPIED
|
|
|
|
assert "last_execution_result" in result
|
|
report = result["last_execution_result"]
|
|
assert len(report["execution"]) == 1
|
|
assert report["execution"][0]["action"] == "tap"
|
|
assert "Pre-execution validation failed" in report["execution"][0]["attempts"][0]
|
|
assert (
|
|
report["execution"][0]["repair"]
|
|
== "Pre-exec failure matched and resolved by switching to Sign Up"
|
|
" button."
|
|
)
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_validator_pre_execution_validation_self_healing(
|
|
mock_mcp, mock_context, temp_screenshot
|
|
):
|
|
"""Test that pre-execution validation succeeds and self-heals when element shifts slightly."""
|
|
mock_live_elements = [
|
|
{
|
|
"text": "Login",
|
|
"bounds": "[100,220][300,320]",
|
|
"resource-id": "btn_login",
|
|
}
|
|
]
|
|
|
|
tapped_coordinates = None
|
|
|
|
def mock_call_tool(name, args):
|
|
nonlocal tapped_coordinates
|
|
if name == "take_screenshot":
|
|
return Mock(content=[Mock(text="ZHVtbXlfZGF0YQ==")])
|
|
if name == "get_ui_hierarchy":
|
|
return Mock(content=[Mock(text=json.dumps(mock_live_elements))])
|
|
if name == "tap":
|
|
tapped_coordinates = args.get("coordinates")
|
|
return Mock(content=[Mock(text="Success")])
|
|
return Mock(content=[Mock(text="Success")])
|
|
|
|
mock_mcp.call_tool.side_effect = mock_call_tool
|
|
|
|
decisions = json.dumps(
|
|
[
|
|
{
|
|
"action": "tap",
|
|
"coordinates": [200, 250],
|
|
"target_text": "Login",
|
|
"target_bounds": [100, 200, 300, 300],
|
|
"target_resource_id": "btn_login",
|
|
}
|
|
]
|
|
)
|
|
|
|
state = DummyState(structured_decisions=decisions, latest_screenshot=temp_screenshot)
|
|
node = ValidatorNode(mock_context)
|
|
|
|
with patch("artemis.utils.image_diff.check_ui_change", return_value=True):
|
|
await node(state)
|
|
|
|
# Center of [100, 220][300, 320] is [200, 270]
|
|
assert tapped_coordinates == [200, 270]
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_validator_pre_execution_validation_anonymous_occupant(
|
|
mock_mcp, mock_context, temp_screenshot
|
|
):
|
|
"""Test that pre-execution validation correctly flags TARGET_OCCUPIED
|
|
when coordinates are blocked by an anonymous clickable view.
|
|
"""
|
|
# The live screen contains an anonymous clickable view covering
|
|
# target coordinates [200, 250]
|
|
mock_live_elements = [
|
|
{
|
|
"text": "",
|
|
"bounds": "[150,200][250,300]",
|
|
"clickable": True,
|
|
"resource-id": "",
|
|
}
|
|
]
|
|
|
|
def mock_call_tool(name, args):
|
|
if name == "take_screenshot":
|
|
return Mock(content=[Mock(text="ZHVtbXlfZGF0YQ==")])
|
|
if name == "get_ui_hierarchy":
|
|
return Mock(content=[Mock(text=json.dumps(mock_live_elements))])
|
|
return Mock(content=[Mock(text="Success")])
|
|
|
|
mock_mcp.call_tool.side_effect = mock_call_tool
|
|
|
|
decisions = json.dumps(
|
|
[
|
|
{
|
|
"action": "tap",
|
|
"coordinates": [200, 250],
|
|
"target_text": "Login",
|
|
"target_bounds": [100, 200, 300, 300],
|
|
"target_resource_id": "btn_login",
|
|
}
|
|
]
|
|
)
|
|
|
|
state = DummyState(structured_decisions=decisions, latest_screenshot=temp_screenshot)
|
|
node = ValidatorNode(mock_context)
|
|
|
|
with (
|
|
patch("artemis.agents.validator.failure_analyzer.FailureAnalyzer.analyze") as mock_analyze,
|
|
patch("artemis.utils.image_diff.check_ui_change", return_value=True),
|
|
patch.object(
|
|
ValidatorNode,
|
|
"_validate_action_precondition_pixel",
|
|
new_callable=AsyncMock,
|
|
) as mock_pixel,
|
|
):
|
|
mock_pixel.return_value = (
|
|
False,
|
|
ValidationErrorCategory.PIXEL_TARGET_DISAPPEARED,
|
|
"Pixel check failed",
|
|
)
|
|
mock_analyze.return_value = {
|
|
"status": "fixed",
|
|
"analysis": "Pre-exec failure bypassed.",
|
|
}
|
|
|
|
await node(state)
|
|
|
|
# Assert that the validator correctly classified this as TARGET_OCCUPIED
|
|
# (due to the clickable anonymous view blocking the click)
|
|
mock_analyze.assert_called_once()
|
|
args, kwargs = mock_analyze.call_args
|
|
assert kwargs.get("error_category") == ValidationErrorCategory.TARGET_OCCUPIED
|
|
assert "occupied/intercepted by a different element: interactive anonymous element" in args[2]
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_validator_pixel_validation_success(mock_mcp, mock_context, temp_screenshot):
|
|
"""Test that the pixel safety net succeeds when Gemini reports target is present."""
|
|
mock_mcp.call_tool.side_effect = [
|
|
Mock(content=[Mock(text="ZHVtbXlfZGF0YQ==")]), # live screenshot for pixel check
|
|
Mock(content=[Mock(text="Success")]), # tap action
|
|
Mock(content=[Mock(text="ZHVtbXlfZGF0YQ==")]), # post-screenshot
|
|
]
|
|
|
|
decisions = json.dumps([{"action": "tap", "coordinates": [100, 200]}])
|
|
state = DummyState(structured_decisions=decisions, latest_screenshot=temp_screenshot)
|
|
|
|
mock_agent_cfg = Mock()
|
|
mock_agent_cfg.provider = "google"
|
|
mock_agent_cfg.model = "gemini-3.5-flash-lite"
|
|
mock_context.llm_config.get_agent.return_value = mock_agent_cfg
|
|
|
|
mock_response = Mock()
|
|
mock_response.text = json.dumps(
|
|
{
|
|
"is_present": True,
|
|
"reason": "Button is clearly visible and clickable.",
|
|
"confidence": 0.95,
|
|
}
|
|
)
|
|
|
|
mock_llm = MagicMock()
|
|
mock_llm.ainvoke = AsyncMock(return_value=AIMessage(content=mock_response.text))
|
|
|
|
# Mock crop and draw helpers to return dummy bytes
|
|
with (
|
|
patch(
|
|
"artemis.utils.visualization.crop_and_annotate_target",
|
|
return_value=b"dummy_bytes",
|
|
),
|
|
patch("artemis.agents.validator.validator.get_llm", return_value=mock_llm),
|
|
patch("artemis.utils.image_diff.check_ui_change", return_value=True),
|
|
):
|
|
node = ValidatorNode(mock_context)
|
|
result = await node(state)
|
|
|
|
assert "last_execution_result" in result
|
|
report = result["last_execution_result"]
|
|
assert len(report["execution"]) == 1
|
|
assert "attempts" not in report["execution"][0]
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_validator_pixel_validation_failure(mock_mcp, mock_context, temp_screenshot):
|
|
"""Test that the pixel safety net fails and triggers FailureAnalyzer
|
|
when Gemini reports target is missing.
|
|
"""
|
|
|
|
def mock_call_tool(name, args):
|
|
if name == "take_screenshot":
|
|
return Mock(content=[Mock(text="ZHVtbXlfZGF0YQ==")])
|
|
return Mock(content=[Mock(text="Success")])
|
|
|
|
mock_mcp.call_tool.side_effect = mock_call_tool
|
|
|
|
decisions = json.dumps([{"action": "tap", "coordinates": [100, 200]}])
|
|
state = DummyState(structured_decisions=decisions, latest_screenshot=temp_screenshot)
|
|
|
|
mock_agent_cfg = Mock()
|
|
mock_agent_cfg.provider = "google"
|
|
mock_agent_cfg.model = "gemini-3.5-flash-lite"
|
|
mock_context.llm_config.get_agent.return_value = mock_agent_cfg
|
|
|
|
mock_response = Mock()
|
|
mock_response.text = json.dumps(
|
|
{
|
|
"is_present": False,
|
|
"reason": "The button has completely disappeared from the screen.",
|
|
"confidence": 0.90,
|
|
}
|
|
)
|
|
|
|
mock_llm = MagicMock()
|
|
mock_llm.ainvoke = AsyncMock(return_value=AIMessage(content=mock_response.text))
|
|
|
|
with (
|
|
patch(
|
|
"artemis.utils.visualization.crop_and_annotate_target",
|
|
return_value=b"dummy_bytes",
|
|
),
|
|
patch("artemis.agents.validator.validator.get_llm", return_value=mock_llm),
|
|
patch("artemis.utils.image_diff.check_ui_change", return_value=False),
|
|
patch("artemis.agents.validator.failure_analyzer.FailureAnalyzer.analyze") as mock_analyze,
|
|
):
|
|
mock_analyze.return_value = {
|
|
"status": "cannot_fix",
|
|
"analysis": "Pixel safety net flagged missing target.",
|
|
}
|
|
|
|
node = ValidatorNode(mock_context)
|
|
await node(state)
|
|
|
|
mock_analyze.assert_called_once()
|
|
args, kwargs = mock_analyze.call_args
|
|
assert "Pixel-level validation failed" in args[2]
|
|
assert kwargs.get("error_category") == ValidationErrorCategory.PIXEL_TARGET_DISAPPEARED
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
@patch("artemis.agents.validator.validator.find_package")
|
|
@patch("artemis.utils.app_launch_utils.launch_app_with_retries")
|
|
async def test_validator_launch_app_passes_use_fallback_mcp(
|
|
mock_launch_app, mock_find_package, mock_mcp, mock_context, temp_screenshot
|
|
):
|
|
"""Test that ValidatorNode calls find_package with use_fallback=False
|
|
for launch_app action in MCP mode.
|
|
"""
|
|
mock_find_package.return_value = "com.example.app"
|
|
mock_launch_app.return_value = (True, None)
|
|
|
|
# Mock MCP calls: screenshot (pre), screenshot (post)
|
|
mock_mcp.call_tool.side_effect = [
|
|
Mock(content=[Mock(text="ZHVtbXlfZGF0YQ==")]), # pre-screenshot
|
|
Mock(content=[Mock(text="ZHVtbXlfZGF0YQ==")]), # post-screenshot
|
|
]
|
|
|
|
decisions = json.dumps([{"action": "launch_app", "app_name": "My App"}])
|
|
state = DummyState(structured_decisions=decisions, latest_screenshot=temp_screenshot)
|
|
|
|
with patch("artemis.utils.image_diff.check_ui_change", return_value=True):
|
|
node = ValidatorNode(mock_context)
|
|
result = await node(state)
|
|
|
|
mock_find_package.assert_called_once_with(mock_context, "My App", use_fallback=False)
|
|
mock_launch_app.assert_called_once_with(mock_context, "com.example.app")
|
|
assert "last_execution_result" in result
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
@patch("artemis.agents.validator.validator.find_package")
|
|
@patch("artemis.utils.app_launch_utils.launch_app_with_retries")
|
|
async def test_validator_launch_app_failure_no_retry(
|
|
mock_launch_app, mock_find_package, mock_mcp, mock_context, temp_screenshot
|
|
):
|
|
"""Test that ValidatorNode does NOT retry launch_app action on failure."""
|
|
mock_find_package.return_value = "com.example.app"
|
|
mock_launch_app.return_value = (False, "Error: Force close")
|
|
|
|
def mock_call_tool(name, args):
|
|
if name == "take_screenshot":
|
|
return Mock(content=[Mock(text="ZHVtbXlfZGF0YQ==")])
|
|
return Mock(content=[Mock(text="Success")])
|
|
|
|
mock_mcp.call_tool.side_effect = mock_call_tool
|
|
|
|
decisions = json.dumps([{"action": "launch_app", "app_name": "My App"}])
|
|
state = DummyState(structured_decisions=decisions, latest_screenshot=temp_screenshot)
|
|
|
|
with (
|
|
patch("artemis.agents.validator.validator.VALIDATOR_POLL_TIMEOUT", 0.05),
|
|
patch("artemis.agents.validator.validator.VALIDATOR_POLL_INTERVAL", 0.01),
|
|
patch("artemis.agents.validator.failure_analyzer.FailureAnalyzer.analyze") as mock_analyze,
|
|
patch("artemis.utils.image_diff.check_ui_change", return_value=False),
|
|
):
|
|
mock_analyze.return_value = {
|
|
"status": "cannot_fix",
|
|
"analysis": "Cannot launch app.",
|
|
}
|
|
|
|
node = ValidatorNode(mock_context)
|
|
result = await node(state)
|
|
|
|
# Verify find_package was called only once
|
|
mock_find_package.assert_called_once_with(mock_context, "My App", use_fallback=False)
|
|
# Verify launch_app_with_retries was called only once
|
|
# (no retry by ValidatorNode itself since it relies on launch_app_with_retries)
|
|
mock_launch_app.assert_called_once_with(mock_context, "com.example.app")
|
|
|
|
# Verify attempts list has only 1 element
|
|
assert "last_execution_result" in result
|
|
report = result["last_execution_result"]
|
|
assert len(report["execution"]) == 1
|
|
assert report["execution"][0]["action"] == "launch_app"
|
|
assert report["execution"][0]["attempts"] == ["Error: Force close"]
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_validator_pre_execution_validation_disappeared_not_shifted(
|
|
mock_mcp, mock_context, temp_screenshot
|
|
):
|
|
"""Test that a disappeared small button matching text in a giant container
|
|
is classified as TARGET_DISAPPEARED, not TARGET_SHIFTED.
|
|
"""
|
|
# Live hierarchy only contains a giant background/container
|
|
# containing the text "Sign Up"
|
|
mock_live_elements = [
|
|
{
|
|
"text": "Sign Up",
|
|
"bounds": "[0,0][1080,2400]",
|
|
"resource-id": "root_container",
|
|
}
|
|
]
|
|
|
|
def mock_call_tool(name, args):
|
|
if name == "take_screenshot":
|
|
return Mock(content=[Mock(text="ZHVtbXlfZGF0YQ==")])
|
|
if name == "get_ui_hierarchy":
|
|
return Mock(content=[Mock(text=json.dumps(mock_live_elements))])
|
|
return Mock(content=[Mock(text="Success")])
|
|
|
|
mock_mcp.call_tool.side_effect = mock_call_tool
|
|
|
|
decisions = json.dumps(
|
|
[
|
|
{
|
|
"action": "tap",
|
|
"coordinates": [200, 250],
|
|
"target_text": "Sign Up",
|
|
"target_bounds": [100, 200, 300, 300],
|
|
"target_resource_id": "btn_signup",
|
|
}
|
|
]
|
|
)
|
|
|
|
state = DummyState(structured_decisions=decisions, latest_screenshot=temp_screenshot)
|
|
node = ValidatorNode(mock_context)
|
|
|
|
with (
|
|
patch("artemis.agents.validator.failure_analyzer.FailureAnalyzer.analyze") as mock_analyze,
|
|
patch("artemis.utils.image_diff.check_ui_change", return_value=True),
|
|
patch.object(
|
|
ValidatorNode,
|
|
"_validate_action_precondition_pixel",
|
|
new_callable=AsyncMock,
|
|
) as mock_pixel,
|
|
):
|
|
mock_pixel.return_value = (
|
|
False,
|
|
ValidationErrorCategory.PIXEL_TARGET_DISAPPEARED,
|
|
"Pixel check failed",
|
|
)
|
|
mock_analyze.return_value = {
|
|
"status": "cannot_fix",
|
|
"analysis": "Sign Up button disappeared.",
|
|
}
|
|
|
|
await node(state)
|
|
|
|
# Assert that the validator correctly classified this as TARGET_DISAPPEARED
|
|
# (since size mismatch prevents shift matching)
|
|
mock_analyze.assert_called_once()
|
|
args, kwargs = mock_analyze.call_args
|
|
assert kwargs.get("error_category") == ValidationErrorCategory.TARGET_DISAPPEARED
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_validator_pre_execution_validation_ocr_direct_to_pixel(
|
|
mock_mcp, mock_context, temp_screenshot
|
|
):
|
|
"""Test that OCR-derived elements bypass XML validation and
|
|
directly use pixel-based validation.
|
|
"""
|
|
mock_mcp.call_tool.side_effect = [
|
|
Mock(content=[Mock(text="ZHVtbXlfZGF0YQ==")]), # live screenshot for pixel check
|
|
Mock(content=[Mock(text="Success")]), # tap action
|
|
Mock(content=[Mock(text="ZHVtbXlfZGF0YQ==")]), # post-screenshot
|
|
]
|
|
|
|
decisions = json.dumps(
|
|
[
|
|
{
|
|
"action": "tap",
|
|
"coordinates": [200, 250],
|
|
"target_text": "Login",
|
|
"target_bounds": [100, 200, 300, 300],
|
|
"target_class": "android.view.View [OCR]",
|
|
}
|
|
]
|
|
)
|
|
|
|
state = DummyState(structured_decisions=decisions, latest_screenshot=temp_screenshot)
|
|
node = ValidatorNode(mock_context)
|
|
|
|
with (
|
|
patch.object(
|
|
ValidatorNode,
|
|
"_validate_action_precondition",
|
|
new_callable=AsyncMock,
|
|
) as mock_xml,
|
|
patch.object(
|
|
ValidatorNode,
|
|
"_validate_action_precondition_pixel",
|
|
new_callable=AsyncMock,
|
|
) as mock_pixel,
|
|
patch("artemis.utils.image_diff.check_ui_change", return_value=True),
|
|
):
|
|
mock_pixel.return_value = (True, ValidationErrorCategory.NONE, "")
|
|
|
|
result = await node(state)
|
|
|
|
# Assert XML validation was NOT called
|
|
mock_xml.assert_not_called()
|
|
# Assert Pixel validation WAS called
|
|
mock_pixel.assert_called_once()
|
|
|
|
assert "last_execution_result" in result
|
|
report = result["last_execution_result"]
|
|
assert report["status"] == "success"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_validator_pre_execution_xml_failure_not_overridden_when_pixel_bypassed(
|
|
mock_mcp, mock_context, temp_screenshot
|
|
):
|
|
"""Test that when XML validation fails AND Pixel validation is bypassed
|
|
(PIXEL_BYPASSED), the XML failure is NOT overridden.
|
|
"""
|
|
mock_live_elements = [
|
|
{
|
|
"text": "Sign Up",
|
|
"bounds": "[100,200][300,300]",
|
|
"resource-id": "btn_signup",
|
|
}
|
|
]
|
|
|
|
def mock_call_tool(name, args):
|
|
if name == "take_screenshot":
|
|
return Mock(content=[Mock(text="ZHVtbXlfZGF0YQ==")])
|
|
if name == "get_ui_hierarchy":
|
|
return Mock(content=[Mock(text=json.dumps(mock_live_elements))])
|
|
return Mock(content=[Mock(text="Success")])
|
|
|
|
mock_mcp.call_tool.side_effect = mock_call_tool
|
|
|
|
decisions = json.dumps(
|
|
[
|
|
{
|
|
"action": "tap",
|
|
"coordinates": [200, 250],
|
|
"target_text": "Login",
|
|
"target_bounds": [100, 200, 300, 300],
|
|
"target_resource_id": "btn_login",
|
|
}
|
|
]
|
|
)
|
|
|
|
state = DummyState(structured_decisions=decisions, latest_screenshot=temp_screenshot)
|
|
node = ValidatorNode(mock_context)
|
|
|
|
with (
|
|
patch("artemis.agents.validator.failure_analyzer.FailureAnalyzer.analyze") as mock_analyze,
|
|
patch("artemis.utils.image_diff.check_ui_change", return_value=True),
|
|
patch.object(
|
|
ValidatorNode,
|
|
"_validate_action_precondition_pixel",
|
|
new_callable=AsyncMock,
|
|
) as mock_pixel,
|
|
):
|
|
# Pixel check was bypassed due to VLM error or low confidence
|
|
mock_pixel.return_value = (
|
|
True,
|
|
ValidationErrorCategory.PIXEL_BYPASSED,
|
|
"",
|
|
)
|
|
mock_analyze.return_value = {
|
|
"status": "cannot_fix",
|
|
"analysis": ("XML validation failed and pixel bypass did not override."),
|
|
}
|
|
|
|
await node(state)
|
|
|
|
# FailureAnalyzer SHOULD be called because XML validation failed
|
|
# and PIXEL_BYPASSED did not override it
|
|
mock_analyze.assert_called_once()
|
|
args, kwargs = mock_analyze.call_args
|
|
assert "Pre-execution validation failed" in args[2]
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_validator_failure_screenshot_mcp_error_handled_safely(
|
|
mock_mcp, mock_context, temp_screenshot
|
|
):
|
|
"""Test that when take_screenshot fails on MCP server and returns an error text,
|
|
the ValidatorNode does not crash with base64 decoding error.
|
|
"""
|
|
def mock_call_tool(name, args):
|
|
if name == "take_screenshot":
|
|
return Mock(content=[Mock(text="Error: ADB connection lost")])
|
|
if name == "tap":
|
|
return Mock(content=[Mock(text="Error: Target not found")])
|
|
return Mock(content=[Mock(text="Success")])
|
|
|
|
mock_mcp.call_tool.side_effect = mock_call_tool
|
|
|
|
decisions = json.dumps([{"action": "tap", "coordinates": [105, 205]}])
|
|
state = DummyState(structured_decisions=decisions, latest_screenshot=temp_screenshot)
|
|
node = ValidatorNode(mock_context)
|
|
|
|
with (
|
|
patch("artemis.agents.validator.failure_analyzer.FailureAnalyzer.analyze") as mock_analyze,
|
|
patch("artemis.utils.image_diff.check_ui_change", return_value=False),
|
|
):
|
|
mock_analyze.return_value = {
|
|
"status": "cannot_fix",
|
|
"analysis": "Action failed and cannot fix.",
|
|
}
|
|
|
|
result = await node(state)
|
|
|
|
assert "last_execution_result" in result
|
|
report = result["last_execution_result"]
|
|
assert report["status"] == "failed"
|
|
assert len(report["execution"]) == 1
|
|
assert report["execution"][0]["action"] == "tap"
|
|
|