How To Do Electron App Testing | Complete Guide

TestComplete is pretty friendly with standard web elements. Here's what you can interact with:

• <p>, <div>, <span>: For text and content containers

• <table>: To work with tabular data

• <input>: Text fields, checkboxes, radio buttons

• <select>: Dropdowns and list boxes

• <button>: Clickable buttons

• <a>: Hyperlinks

But wait, there's more! TestComplete also plays nice with:

• Custom elements: If it's built on standard web tech, chances are you can interact with it.

• Complex UI components: Things like date pickers, sliders, or custom dropdowns.

Remember: If a human can interact with it, TestComplete probably can too!

Putting It All Together

Imagine you're filling out a form in your Electron app. Your test might look something like this:

var orderForm = Aliases.orders.pageOrders.formOrder;
orderForm.textboxCustomerName.SetText("John Doe");
orderForm.selectProduct.ClickItem("Awesome Widget");
orderForm.textboxQuantity.SetText("5");
orderForm.buttonSubmit.Click();

It's like writing a script for a very meticulous user!

Pro Tip: Always think about the most efficient and reliable way to interact with elements. Sometimes, a single Click() is better than a complex series of mouse movements.

By mastering these methods and understanding which elements you can work with, you're well on your way to creating robust, reliable tests for your Electron app. It's like being a puppeteer, but instead of strings, you're using code to make your app perform!

Leveling Up Your Testing Game: Best Practices and Pitfalls

Let's dive into some pro tips and potential stumbling blocks in Electron app testing. Knowing these can save you hours of head-scratching!

Best Practices: The Secret Sauce

1. Finding the Right Binary Executable

Think of this as finding the true heart of your app. Here's how:

• Look in the %APPDATA%\Local<Your_App_Name>\app-N.N.N folder.

• Use the actual app executable, not just a launcher.

Pro Tip: If you're not sure, let TestComplete be your guide:

1. Launch your Electron app.

2. In TestComplete's Object Browser, find your app.

3. Right-click the Process node and select "Add Process to TestedApps". Voila! You've got the right executable.

4. Taming Background Electron Apps

Background Electron apps can be like sneaky photobombers in your tests. Here's how to handle them:

• Before testing, check Task Manager for any Electron processes.

• Close all background Electron apps.

Why? These silent runners can confuse TestComplete, leading to wonky test results. It's like trying to have a conversation in a noisy room – best to quiet things down first!

Limitations and Known Issues: The "Gotchas"

1. Cross-Platform Testing Limitations

Bad news: Running cross-platform web tests for Electron apps in remote environments isn't supported.

What this means: You'll need to test on each platform separately. It's like needing different keys for different doors – a bit more work, but ensures everything's locked tight.

2. Version-Specific Issues

Electron is like a fast-moving train, and sometimes testing tools need to catch up. Here are some version-specific quirks:

• Electron 9.x and up: Not supported on Windows 7.

• Electron 9.x and 11.0.0 with global sandbox mode: Not supported.

• Electron 12 and later: May freeze or crash during test recording.

Pro Tip: Always check the latest compatibility notes for your Electron version. It's like reading the weather forecast before a trip – helps you prepare!

3. Content Security Policy (CSP) Restrictions

If your app uses strict CSP, it might block TestComplete's script injection. The fix? Create a separate test build with relaxed CSP. Just remember: Don't use this build in production!

4. JavaScript Library Conflicts

Using popular JS libraries? You might see "Uncaught ReferenceError" when launching. The fix: Use the -tearOffNodeObjects command-line argument when launching your app for testing.

Remember, these limitations aren't roadblocks – they're more like speed bumps. Knowing them helps you navigate your testing journey more smoothly.

By following these best practices and being aware of the limitations, you're setting yourself up for testing success. It's like having a map and knowing the terrain before embarking on an adventure – you're prepared for whatever comes your way!

Keeping Up with the Times: Migrating Existing Tests

So, you've been testing your Electron app for a while, and now you've updated TestComplete. What happens to your trusty old tests? Don't worry, we've got you covered!

Migrating Tests: Out with the Old, In with the New(ish)

Good news: If you're updating from a TestComplete version prior to 14.93, your existing tests won't suddenly turn into pumpkins at midnight. They'll still work! But, like upgrading from a flip phone to a smartphone, there are some new features you might want to take advantage of.

Here's your quick and easy migration guide:

1. Keep Calm and Test On Your old tests will still run. No need to panic or rewrite everything from scratch. It's like finding out your old car still works great on new roads.

2. Embrace the CDP CDP (Chrome DevTools Protocol) is the new cool kid on the block. It's like switching from snail mail to email – faster, more efficient, and with cooler features.

3. The Magic Parameter Here's the secret sauce for upgrading your tests:

   • Find your Electron app in the Tested Applications collection of your project.

   • Add this magic spell: -cdpAutoSetPort

   • Add it as a command-line parameter to your app's launch settings.

4. It's like teaching your old dog a neat new trick!

5. Leave the Rest Alone Good news: You don't need to touch any other test commands. They'll work just fine with the new setup.

Pro Tip: While your old tests will work, consider gradually updating them to take full advantage of the new features in TestComplete 14.93 and later. It's like upgrading your wardrobe one piece at a time – no need to do it all at once!

Why Bother Migrating?

You might be thinking, "If it ain't broke, don't fix it," right? Well, here's why upgrading is a good idea:

1. Better Performance: CDP is generally faster and more reliable.

2. More Features: You get access to newer testing capabilities.

3. Future-Proofing: Staying updated helps ensure your tests work with newer Electron versions.

4. Bug Fixes: New versions often come with fixes for known issues.

Think of it as tuning up your car – it'll run smoother and last longer!

A Word of Caution

If you're using the legacy script injection method (pre-14.93), be aware that it comes with some limitations and potential issues. It's like using an old map – it might get you there, but newer routes are often better.

Wrapping Up the Migration

Migrating your tests doesn't have to be a headache. With TestComplete, it's more like a gentle nudge into the future. Your old tests still work, but with a simple tweak, you can unlock a world of new testing possibilities.

Remember, the goal is to make your testing more efficient and effective. By updating your tests, you're not just keeping up with the times – you're setting yourself up for easier, more robust testing in the future.