Skip to content

App Development

Stabilizing Web E2E Testing Through Graph-Guided LLM Generation

Web E2E testing often breaks when dynamic page flows and conditional forms are scripted manually or delegated solely to LLM agents. An arXiv architecture combines screen transition graphs for navigation with state graphs for conditional form filling to generate Selenium test scripts.

Editorial illustration about Stabilizing Web E2E Testing Through Graph-Guided LLM Generation in App Development.

End-to-end web testing often fails for a mundane reason: application interfaces change faster than teams can rewrite brittle browser scripts. Hand-coded Selenium suites cover known paths well, yet maintaining them across dynamic routes and multi-step forms drains engineering capacity.

Research on arXiv introduces an automated test generation architecture that pairs graph models with Large Language Models. The system anchors test generation in screen transition graphs and state graphs instead of delegating raw HTML exploration to an unconstrained agent. This design keeps page navigation and form validation inside one unified workflow.

In short

  • Architectural impact: A two-graph pipeline replaces manually authored Selenium scripts by using screen transition graphs for navigation and state graphs for conditional forms.
  • Operational value: QA and product teams reduce manual test authoring bottlenecks while expanding coverage across interconnected routes and multi-field validation logic.
  • Engineering boundary: Deterministic graphs constrain valid application states and transitions, while an LLM generates scenarios and Selenium scripts within those bounds.
  • Main trade-off: Teams gain wider coverage across dynamic interfaces, yet they incur upfront modeling overhead to keep transition and state graphs accurate.

Where Manual Scripts and Pure LLM Agents Break

Traditional static analysis, dynamic checks, and pre-recorded suites struggle to keep pace with large interactive web applications. Even programmatic tools like Selenium typically rely on engineers writing and updating test cases by hand. In fast-moving products, that manual loop leaves coverage gaps on critical user journeys.

Unconstrained LLM browsing agents attempt to automate navigation directly from raw page markup, but they hit structural limits. Verbose and deeply nested HTML obscures intent, forcing prior systems to add HTML simplification layers or multimodal parsing. More importantly, pure LLM navigation often misses conditional form fields that only appear after specific inputs or validation rules.

Another blind spot sits between page routing and data entry. Many existing test tools model site navigation and form validation as disconnected steps. When a checkout or onboarding flow mixes page transitions with dependent input fields, separate tools produce incomplete scenarios that fail in production.

Separating Navigation Graphs From Conditional Form State

The arXiv system closes that gap by splitting the E2E problem into two coupled graph representations. Screen transition graphs map how users move between pages across the web application. Large Language Models read those navigation graphs to generate end-to-end test scenarios that reflect real multi-page paths rather than isolated clicks.

Form interactions receive a dedicated state graph rather than ad-hoc prompting. Conditional fields, mandatory inputs, and input-dependent validation rules become explicit nodes and transitions inside the form state model. From those state graphs, the pipeline automates Selenium script generation so execution stays repeatable in a standard browser runner.

Experimental evaluations reported in the paper show higher test coverage and stronger resilience than baseline approaches across both navigation and form tasks. The authors also release a benchmark dataset built specifically for evaluating form-interaction testing, giving engineering teams a concrete reference beyond synthetic single-page demos.

Workflow Consequences for Engineering and QA Teams

For builders, the primary takeaway is structural rather than model-centric. Encoding navigation flows and conditional form logic in explicit graphs prevents an LLM from guessing nonexistent routes or skipping required validation branches. Teams also avoid vendor lock-in because the pipeline emits standard Selenium scripts rather than requiring a proprietary agent runtime.

For engineering leaders and process owners, graph-backed generation shifts QA effort from repetitive script maintenance toward maintaining accurate workflow specifications. That shift reduces manual handoffs between feature developers and test writers when conditional forms evolve. Teams still carry a clear architectural prerequisite: graph models stay reliable only when changes to routes and form rules update the underlying graphs.

The scope of the research remains explicitly web-focused. Its architecture targets browser interfaces through HTML structures and Selenium, leaving native mobile E2E orchestration unaddressed.

Graph-guided E2E generation pays off only when extracting transition and form state graphs takes less effort than maintaining Selenium scripts by hand. Applications with constantly shifting, unmodeled UI experiments will still expose the cost of keeping those graphs current.

Source

Similar posts

PROJECT INQUIRY

Automate a business process?

Tell us which process currently takes too much time or manual effort. Together we examine what an executable workflow for it looks like, and reply personally.

Your information is treated confidentially in accordance with our Privacy Policy.