Telerik Test Studio: Desktop and Web Testing for .NET Teams

Telerik Test Studio: Desktop and Web Testing for .NET Teams

Telerik Test Studio is a commercial test automation platform from Progress (the company behind Telerik UI components). It targets .NET development teams with a hybrid approach: record-and-replay for quick test creation, combined with a full scripting API for complex scenarios.

If your team builds WPF, WinForms, or ASP.NET applications and wants a unified tool for both web and desktop testing, Test Studio is one of the few options designed for this combination.

What Is Telerik Test Studio?

Test Studio provides:

  • Web testing: Chrome, Firefox, Edge, Safari support via a browser extension
  • Desktop testing: WinForms, WPF, MFC, and generic Windows desktop apps
  • Mobile testing: iOS and Android via an add-on
  • Load testing: Basic load test capabilities built in
  • Record and replay: Visual test recorder for non-programmers
  • Scripting: C# and VB.NET scripting for complex logic
  • Visual Studio integration: Tests run inside VS or the standalone IDE

The target user is a QA engineer or SDET at a company using the Microsoft stack.

Installation

Test Studio requires Windows. Download the installer from the Progress website. The installer includes:

  • Test Studio IDE: Standalone test authoring and execution environment
  • Visual Studio plugin: Integrates with VS 2019/2022

A free trial is available; the licensed product requires a subscription (pricing varies by team size).

Creating Your First Web Test

Record Mode

  1. Open Test Studio and create a new project
  2. Add a new Web Test
  3. Click Record and select the browser
  4. Navigate to your application — Test Studio captures each interaction
  5. Stop recording
  6. Review the generated test steps

The recorder creates a readable list of steps:

Navigate to 'https://app.example.com/login'
Set text in 'email_input' to 'user@example.com'
Set text in 'password_input' to 'secret'
Click 'submit_button'
Verify 'dashboard_header' exists

Adding Verifications

Right-click any element in the recording to add verifications:

  • Exists: element is present in the DOM
  • Text contains: element's text matches
  • Attribute equals: any HTML attribute value
  • Image: visual match against a baseline screenshot

Script Mode (C#)

For logic that can't be recorded, switch to code:

[TestMethod]
public void TestLoginFlow()
{
    // Navigate
    ActiveBrowser.NavigateTo("https://app.example.com/login");
    
    // Find elements
    HtmlInputText emailField = ActiveBrowser
        .Find.ById<HtmlInputText>("email");
    HtmlInputText passwordField = ActiveBrowser
        .Find.ById<HtmlInputText>("password");
    HtmlButton submitButton = ActiveBrowser
        .Find.ByExpression<HtmlButton>("TextContent=Sign In");
    
    // Interact
    emailField.Text = "user@example.com";
    passwordField.Text = "secret";
    submitButton.Click();
    
    // Verify
    ActiveBrowser.WaitForElement(
        new HtmlFindExpression("id=dashboard"), 
        5000, 
        false
    );
    
    Assert.IsTrue(
        ActiveBrowser.Find.ById("dashboard").IsVisible()
    );
}

Desktop Application Testing

Test Studio's desktop testing is distinct from its web testing and is one of its differentiating features.

WPF Application Testing

[TestMethod]
public void TestWpfCalculator()
{
    // Launch the application
    var app = new Application();
    app.LaunchNewInstance(@"C:\Apps\Calculator.exe");
    
    var mainWindow = app.WaitForWindow("Calculator");
    
    // Find WPF elements by automation ID
    var button5 = mainWindow
        .Find.ByAutomationId<WpfButton>("5Button");
    var buttonPlus = mainWindow
        .Find.ByAutomationId<WpfButton>("plusButton");
    var button3 = mainWindow
        .Find.ByAutomationId<WpfButton>("3Button");
    var buttonEquals = mainWindow
        .Find.ByAutomationId<WpfButton>("equalsButton");
    var result = mainWindow
        .Find.ByAutomationId<WpfTextBlock>("ResultTextBlock");
    
    // Perform calculation: 5 + 3
    button5.Click();
    buttonPlus.Click();
    button3.Click();
    buttonEquals.Click();
    
    // Verify result
    Assert.AreEqual("8", result.Text);
}

WinForms Testing

[TestMethod]
public void TestWinFormsGrid()
{
    var app = new Application();
    app.LaunchNewInstance(@"C:\Apps\DataManager.exe");
    
    var mainWindow = app.WaitForWindow("Data Manager");
    
    // Find a DataGridView
    var grid = mainWindow
        .Find.ByName<WinFormsGrid>("dataGridView1");
    
    // Verify row count
    Assert.AreEqual(10, grid.Rows.Count);
    
    // Click first row
    grid.Rows[0].Cells[0].Click();
    
    // Verify detail panel updates
    var detailPanel = mainWindow.Find.ByName<WinFormsPanel>("detailPanel");
    Assert.IsTrue(detailPanel.Find.ByName("nameLabel").Text.Length > 0);
}

Element Explorer

The Element Explorer is Test Studio's repository for storing element references. Instead of locating elements inline in every test, you define them once and reuse across tests:

  1. Record a test or manually add elements
  2. Elements appear in the Element Explorer with their find expressions
  3. Reference them by name in tests

This is similar to Page Objects but maintained in a visual UI rather than code.

Data-Driven Testing

Test Studio supports external data sources natively:

// Data source: CSV file or Excel sheet
// Columns: email, password, expected_result

[TestMethod]
[DataSource("LoginData.xlsx")]
public void TestLoginDataDriven()
{
    string email = Data["email"].ToString();
    string password = Data["password"].ToString();
    string expected = Data["expected_result"].ToString();
    
    ActiveBrowser.NavigateTo("https://app.example.com/login");
    ActiveBrowser.Find.ById<HtmlInputText>("email").Text = email;
    ActiveBrowser.Find.ById<HtmlInputText>("password").Text = password;
    ActiveBrowser.Find.ByExpression<HtmlButton>("TextContent=Sign In").Click();
    
    var message = ActiveBrowser.Find.ByCssSelector(".auth-message");
    StringAssert.Contains(message.TextContent, expected);
}

CI Integration

Azure DevOps

Test Studio integrates directly with Azure DevOps:

  1. Install the Test Studio Azure DevOps extension
  2. Add a Test Studio task to your pipeline:
- task: RunTestStudioTests@1
  inputs:
    testPath: '$(Build.SourcesDirectory)/Tests'
    outputPath: '$(Build.ArtifactStagingDirectory)/results'
    testRunSettings: 'Settings/ci-settings.aiis'

Command Line (MSBuild)

# Run from command line
ArtOfTest.Runner.exe /list projectfolder /results results.xml

# Run specific test
ArtOfTest.Runner.exe /test "Tests\Login\LoginTest.tstest" /results results.xml

GitHub Actions

name: Test Studio Tests

on: [push]

jobs:
  test:
    runs-on: windows-latest
    
    steps:
      - uses: actions/checkout@v3
      
      - name: Install Test Studio
        run: |
          # Download and install Test Studio CLI
          # (requires license key in secrets)
          
      - name: Run tests
        run: |
          ArtOfTest.Runner.exe /list ${{ github.workspace }}\Tests /results results.xml
        env:
          TS_LICENSE: ${{ secrets.TEST_STUDIO_LICENSE }}
      
      - name: Publish results
        uses: actions/upload-artifact@v3
        with:
          name: test-results
          path: results.xml

Test Studio vs Alternatives

Tool Web Desktop Language Cost
Test Studio Yes WPF/WinForms C#/VB.NET Paid
Selenium Yes No Multi Free
Playwright Yes No Multi Free
WinAppDriver No Windows C# Free
TestComplete Yes Yes JS/Python/VB Paid
Ranorex Yes Yes C#/VB Paid

For pure web testing, Playwright and Selenium are more capable and free. Test Studio's value is in the combination of web and WPF/WinForms desktop testing under one roof.

Pricing and Licensing

Test Studio uses a subscription model. Pricing is not publicly listed — contact Progress for a quote. Typical tiers:

  • Developer: Individual developer license
  • Testing: QA-focused license with more execution capabilities
  • Enterprise: Volume licensing with priority support

The tooling is Windows-only, which limits cross-platform teams.

Limitations

Windows only. No Mac or Linux support. If your CI runs Linux, desktop testing won't work there.

Proprietary format. Test files use Test Studio's own format. Migrating away means rewriting tests.

Cost. Compared to open-source alternatives, the subscription cost is significant for small teams.

Web testing is behind open-source tools. For web-only testing, Playwright's API is more powerful and the community is larger.

Learning curve for the IDE. The Test Studio IDE is complex. Teams used to code-first workflows may find the visual tooling cumbersome.

When Test Studio Makes Sense

Test Studio is worth evaluating when:

  • You need to test both WPF/WinForms desktop apps and web apps in one framework
  • Your team is comfortable with Microsoft tooling (VS, C#, Azure DevOps)
  • You have non-technical QA staff who need a visual test authoring tool
  • The application under test uses Telerik UI components (Test Studio has built-in support)

If you're testing web only, or your team is experienced with code-based frameworks, the open-source alternatives are a better fit.

Summary

Telerik Test Studio occupies a specific niche: test automation for teams building both Windows desktop and web applications on the Microsoft stack. Its record-replay authoring, C# scripting, and WPF/WinForms support make it one of the few tools that handles this combination without requiring separate toolchains.

The cost and Windows-only constraint are real limitations. But for .NET shops with a mix of desktop and web testing needs, Test Studio is a mature, well-supported option.

Read more

Start now free