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
- Open Test Studio and create a new project
- Add a new Web Test
- Click Record and select the browser
- Navigate to your application — Test Studio captures each interaction
- Stop recording
- 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' existsAdding 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:
- Record a test or manually add elements
- Elements appear in the Element Explorer with their find expressions
- 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:
- Install the Test Studio Azure DevOps extension
- 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.xmlGitHub 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.xmlTest 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.