dotnet-uno-testing

name	dotnet-uno-testing
description	Tests Uno Platform apps. Playwright for WASM, platform-specific patterns, runtime heads.
allowed-tools	["Read","Grep","Glob","Bash","Write","Edit"]

dotnet-uno-testing

Testing Uno Platform applications across target heads (WASM, Desktop, Mobile). Covers Playwright-based browser automation for Uno WASM apps, platform-specific testing patterns for different runtime heads, and test infrastructure for cross-platform Uno projects.

Version assumptions: .NET 8.0+ baseline, Uno Platform 5.x+, Playwright 1.40+ for WASM testing. Uno Platform uses single-project structure with multiple target frameworks.

Scope

• Playwright-based browser automation for Uno WASM apps
• Platform-specific testing patterns for different runtime heads
• Test infrastructure for cross-platform Uno projects

Out of scope

• Shared UI testing patterns (page object model, selectors, wait strategies) -- see [skill:dotnet-ui-testing-core]
• Playwright fundamentals (installation, CI caching, trace viewer) -- see [skill:dotnet-playwright]
• Test project scaffolding -- see [skill:dotnet-add-testing]

Prerequisites: Uno Platform application with WASM head configured. For WASM testing: Playwright browsers installed (see [skill:dotnet-playwright]). For mobile testing: platform SDKs configured (Android SDK, Xcode).

Cross-references: [skill:dotnet-ui-testing-core] for page object model and selector strategies, [skill:dotnet-playwright] for Playwright installation, CI caching, and trace viewer, [skill:dotnet-uno-platform] for Uno Extensions, MVUX, Toolkit, and theme guidance, [skill:dotnet-uno-targets] for per-target deployment and platform-specific gotchas.

---

Uno Testing Strategy by Head

Uno Platform apps run on multiple heads (WASM, Desktop/Skia, iOS, Android, Windows). Each head has different testing tools and trade-offs.

Head	Testing Approach	Tool	Speed	Fidelity
WASM	Browser automation	Playwright	Medium	High -- real browser rendering
Desktop (Skia/GTK, WPF)	UI automation	Appium / WinAppDriver	Medium	High -- real desktop rendering
iOS	Simulator automation	Appium + XCUITest	Slow	Highest -- real iOS rendering
Android	Emulator automation	Appium + UIAutomator2	Slow	Highest -- real Android rendering
Unit (shared logic)	In-memory	xUnit (no UI)	Fast	N/A -- logic only

Recommended priority: Test shared business logic with unit tests first. Use Playwright against the WASM head for UI verification -- it is the fastest UI testing path with the broadest coverage. Add platform-specific Appium tests only for behaviors that differ between heads.

---

Playwright for Uno WASM

The WASM head renders Uno apps in a browser, making Playwright the natural choice for UI testing.

Test Infrastructure

// NuGet: Microsoft.Playwright
public class UnoWasmFixture : IAsyncLifetime
{
    public IPlaywright Playwright { get; private set; } = null!;
    public IBrowser Browser { get; private set; } = null!;
    public IPage Page { get; private set; } = null!;

    private Process? _serverProcess;

    public async ValueTask InitializeAsync()
    {
        // Start the WASM app (dotnet run or serve the published output)
        _serverProcess = await StartWasmServerAsync();

        Playwright = await Microsoft.Playwright.Playwright.CreateAsync();
        Browser = await Playwright.Chromium.LaunchAsync(new BrowserTypeLaunchOptions
        {
            Headless = true
        });
        Page = await Browser.NewPageAsync();

        // Wait for Uno WASM app to fully load
        await Page.GotoAsync("http://localhost:5000");
        await WaitForUnoAppReadyAsync();
    }

    public async ValueTask DisposeAsync()
    {
        await Page.CloseAsync();
        await Browser.CloseAsync();
        Playwright.Dispose();

        _serverProcess?.Kill(entireProcessTree: true);
        _serverProcess?.Dispose();
    }

    
    {
        
         Page.WaitForSelectorAsync(
            ,
            () { State = WaitForSelectorState.Visible, Timeout = _000 });

        
         Page.WaitForFunctionAsync(
            ,
            ,
            () { Timeout = _000 });
    }

    
    {
         process =  Process
        {
            StartInfo =  ProcessStartInfo
            {
                FileName = ,
                Arguments = ,
                UseShellExecute = ,
                RedirectStandardOutput = ,
                RedirectStandardError = 
            }
        };
        process.Start();

        
          httpClient =  HttpClient();
         deadline = DateTime.UtcNow.AddSeconds();
         (DateTime.UtcNow < deadline)
        {
            
            {
                 resp =  httpClient.GetAsync();
                 (resp.IsSuccessStatusCode) ;
            }
             (HttpRequestException)
            {
                
            }
             Task.Delay();
        }
         process;
    }
}

```text



```csharp

   : <>
{
      IPage _page;

    
    {
        _page = fixture.Page;
    }

    []
    
    {
        
        
         title = _page.Locator();

         Expect(title).ToBeVisibleAsync();
         Expect(title).ToHaveTextAsync();
    }

    []
    
    {
         _page.ClickAsync();

         settingsHeader = _page.Locator();
         Expect(settingsHeader).ToBeVisibleAsync();
         Expect(settingsHeader).ToHaveTextAsync();
    }
}

```text



```csharp

[]

{
     _page.FillAsync(, );
    
     _page.FillAsync(, );
     _page.ClickAsync();

    
     dashboard = _page.Locator();
     Expect(dashboard).ToBeVisibleAsync(
        () { Timeout = _000 });
}

[]

{
     _page.FillAsync(, );
     _page.ClickAsync();

     items = _page.Locator();
     Expect(items).ToHaveCountAsync();
     Expect(items.First).ToContainTextAsync();
}

```text

---





Uno maps `AutomationProperties.AutomationId` to each platformtheme-toggleapp-rootupload-btn-name{automationId}{automationId}{automationId}{automationId}s MVVM pattern means most business logic  testable without any UI framework.
- **Use Playwright + WASM  the primary UI testing path.** It  faster than mobile emulators  provides real rendering fidelity  a browser.
- **Use `AutomationProperties.AutomationId`  all testable controls.** It  the only selector strategy that works identically across all Uno heads.
- **Separate shared tests  platform-specific tests.** Use   classes  shared test logic, concrete subclasses per platform.
- **Add platform-specific tests only  platform-divergent behavior.** File pickers, hardware buttons, gestures,  notifications differ across platforms; test these separately.

---



 **Do  assume Uno WASM apps load instantly.** ; CSS classes are   unstable. Use `data-testid` ( `AutomationProperties.AutomationId`) exclusively.
 **Do  forget to build the WASM head before running Playwright tests.** `dotnet run` builds  demand, but `dotnet publish`  needed  production-like testing. Stale builds cause confusing test failures.
 **Do  test mobile-specific features  the WASM head.** File system access, push notifications, biometrics,  NFC are  available  the browser. Skip  mock these  WASM tests.
 **Do  run all platform tests  a single CI job.** 

Code Navigation (Serena MCP)

Primary approach: Use Serena symbol operations for efficient code navigation:

1. Find definitions: serena_find_symbol instead of text search
2. Understand structure: serena_get_symbols_overview for file organization
3. Track references: serena_find_referencing_symbols for impact analysis
4. Precise edits: serena_replace_symbol_body for clean modifications

When to use Serena vs traditional tools:

• Use Serena: Navigation, refactoring, dependency analysis, precise edits
• Use Read/Grep: Reading full files, pattern matching, simple text operations
• Fallback: If Serena unavailable, traditional tools work fine

Example workflow:

# Instead of:
Read: src/Services/OrderService.cs
Grep: "public void ProcessOrder"

# Use:
serena_find_symbol: "OrderService/ProcessOrder"
serena_get_symbols_overview: "src/Services/OrderService.cs"