We’ve heard you loud and clear and are thrilled to announce that Aqua now supports Cypress, the popular testing framework. Discover the support we’ve crafted to enhance your efficiency while working with Cypress.

DOWNLOAD AQUA

Cypress support

Introducing Aqua’s test visibility

When you open your project, Aqua will automatically detect your Cypress tests and show a run icon next to them in the editor, so that you can easily run your tests with a click of a mouse.

Explore results

Once your tests are completed, Aqua will provide comprehensive test results, including related logs and console outputs for each test. Thanks to various sorting and filtering options, you can quickly navigate through failed or ignored tests and analyze their execution times.

Aqua enables smooth transitions from the test results tool window to the corresponding source code of the selected test.

Efficient test run configuration management

Aqua allows you to easily save and share your test run configurations with different parameters or setups.

Find your tests with ease

Searching for specific test cases is now a breeze with Aqua. Utilize the Go to Symbol or Search Everywhere functionality to locate and jump to the desired test quickly.

Enhanced code editing experience

Enjoy an advanced code editing experience with Aqua. Benefit from JavaScript and TypeScript support, including intelligent code completion, navigation, linter support, and more. Aqua’s Code Insight feature is enhanced to support Cypress-specific functions and expressions. It highlights CSS and XPath locators within string literals and provides relevant code completion suggestions.

Aqua offers first-class support for Cypress aliases. Easily navigate between alias declarations and usages, perform inline renames, and identify unused alias declarations. Aqua also provides warnings for invalid alias usages, such as referencing an alias on the ‘this’ object within an arrow function.

Simplified element inspection and validation

Aqua seamlessly integrates with the embedded Web Inspector, suggesting actual locators for elements on the tested webpage. It supports navigation from source code to elements on the page, highlighting elements in the Web Inspector based on CSS selectors. This feature helps in verifying locator validity and element availability. The Web Inspector will also help inspect the page and validate or generate multiple kinds of locators, ensuring that they are unique and reliable.

Cypress Launchpad

You can instantly access the Launchpad to configure tests for this project by simply clicking the Open Cypress button.

Aqua is more than just an editor

Aqua goes beyond being a mere editor. It streamlines the development and maintenance of Cypress tests. With its integrated Web Inspector, Aqua offers invaluable insights directly within your IDE, enabling real-time, data-driven code completion and effortless navigation.

As a robust IDE, Aqua equips QA professionals with essential tools for their daily workflow, including:

• Database Management: Seamlessly connect to multiple databases and effortlessly prepare and verify application data.
• Editor-based HTTP Client: Execute complex HTTP requests, perform assertions, and effortlessly share them with your team, running them on CI/CD pipelines.
• Docker Support: Simplify container management with Aqua’s built-in capabilities to run, monitor, and configure containers.

In addition to these features, Aqua provides VCS integration, a terminal, and more, ensuring that all your testing needs are met.

We’re thrilled to reach this significant milestone, and we invite you to try out this version of Aqua. Keep in mind that this functionality is in public preview, so if you face any issues, report it on our issue tracker.

Please use our feedback form to share your thoughts, questions, or suggestions. You can conveniently download the latest preview build via the Toolbox App or our website.

Stay up to date with the latest improvements by subscribing to our blog, and don’t forget to follow us on Twitter.

Wishing you successful and efficient automated testing!

The Aqua team

We have been working hard to provide first-class support for the most popular testing frameworks, and Playwright support is something that our users have been requesting for a while. We are excited to announce that the new version of Aqua includes full support for Playwright.

DOWNLOAD AQUA

Playwright support

Aqua shows your tests

When opening your project, Aqua will find your Playwright tests and show gutter icons to run your test from the editor.

Running tests with Playwright is simple and easy. If needed, you can also choose to run all tests from a file or directory.

Explore results and find issues

As a test is finished, Aqua will show detailed test results, and display the related log and console output of that test. With multiple sorting and filtering options, it’s easy to get through all failed or ignored tests or inspect the test’s execution time.

Aqua lets you easily navigate from the test results tool window to the source code of the selected test. For convenience, Aqua displays inlay hints with step execution time and highlights the failed line or expression right in the source code editor, providing the corresponding error message. This provides a seamless user experience.

Save and share your test run settings

If you are running different sets of tests with different parameters or configurations, you can save your settings as a Run Configuration, share the configuration with your team, and instantly switch between the different settings.

Aqua also respects the Playwright.tsconfig file and suggests adjusting it if the selected test file is not in the specified test directory.

Search specific test case

Finding a particular test in the source code can sometimes be tricky, especially when tests are not declared as functions. That’s where Aqua can help. Press ⇧ twice to open the search window and using Go to Symbol or Search everywhere, it’s now easy to find and jump to the specific test you’re looking for.

Debugger

Aqua also provides a debugger for your Playwright tests out of the box inside your IDE. You can set breakpoints to stop the execution and analyze your code.

Enjoy an advanced code editing experience

Aqua comes with top-class JavaScript and TypeScript support, including smart code completion, navigation, linter support, and more.

We enhanced our Code Insight and supported Playwright-specific functions and expressions.
Aqua highlights CSS and XPath locators in string literals and provides the relevant code completion.

If the tested webpage is open in the embedded Web Inspector, Aqua will suggest actual locators for elements on the page.

The same level of support is also available when suggesting real `data-testid`, `aria-label`, `role` attribute values from your web page for `page.getByRole`, `page.getByLabel`, and `page.getByTestId` functions. Aqua follows the data test attribute name from the Playwright configuration file.

Aqua also supports navigation from the source code to the element on your page. If you click on the CSS selector, for instance, or on the attribute value passed to the `page.getByTestId` function, Aqua will highlight the element in the Web Inspector. This helps easily verify whether the locator is valid and the element is available on the page.

The Web Inspector will also help to inspect the page and validate or generate multiple kinds of locators, ensuring that they are unique and reliable.

Aqua makes it easier and more efficient to develop and maintain Playwright tests. Thanks to the embedded Web Inspector that gives valuable insights to the IDE, Aqua can provide real-data code completion and seamless navigation.

Aqua is more than just an editor

As a powerful IDE, Aqua also comes with everything that QA professionals need daily, including:

• Database management, which lets you connect to multiple databases and prepare and verify your application data.

• An editor-based HTTP client that runs complex HTTP requests and assertions and lets you share them with your team and run on the CI/CD system.

• Docker support that runs, monitors, and configures containers.
• VCS, Terminal, and more.

This is a big milestone for us, and we invite you to try this version. Keep in mind that this functionality is in public preview, so if you face any issues, report it on our issue tracker.

Please use this feedback form to share feedback or ask any questions you might have. You can download the latest preview build via the Toolbox App or our website.

Subscribe to our blog to receive news about the latest improvements, and be sure to follow us on Twitter.

Happy automated testing!

The Aqua team

For this update, we want to share some fixes and new features that are ready for you to try. You can download the latest version from our website, update directly from the IDE, or update via the free Toolbox App.

Enhanced testing features include:

• Handling of untrusted websites in the Web Inspector [AQUA-45].
  • Now, when a website is untrusted, we show you a dialog with the certificate’s details, and you can decide whether to accept or reject the certificate. Furthermore, you can see accepted certificates in

  Settings Tool | Server | Certificates.

• Autocomplete options for ID and Class names [AQUA-6].
  Aqua now suggests existing IDs and class names from the web page in the Web Inspector.

Further improvements to the IDE experience:

• Faster import of Maven projects.
• New Java inspections and ​​Java 20 support.
• Improved Extract Method refactoring for Java.
• Autocompletion in the JVM options field.
• Java SDK is now detected from the Gradle toolchain.

• Improved code review workflow for GitHub.
• Merged logs from all Docker Compose containers.
• Support for Azure Container Registry.
• Docker container health statuses are visible in the Services tool window.
• Better code insight for Python generic classes.
• Python Packages tool window enables the management of the attached projects’ packages.
• Usages inlay hints in Code Vision.
• Automatic conversion of strings to template literals for JavaScript and TypeScript.
• Full IDE zoom.
• Improvement in the experience of Markdown editing.

That’s it for now, but don’t worry – we are listening to your feedback. We are almost finished with the support for Cypress and Playwright, so stay tuned for our upcoming release announcements.

Please use this form to share your feedback or ask any questions you might have.

To receive news about the latest improvements, subscribe to our blog and follow us on Twitter!

Happy automated testing!

The Aqua team

We are happy to introduce JetBrains Aqua – a powerful new IDE for test automation. Aqua provides a unique feature set distinct from existing JetBrains products. In Aqua, we’ve assembled everything a test automation engineer needs on a daily basis, including a multi-language IDE (with support for JVM, Python, and JavaScript, and others), an HTTP client, database management functionality, Docker support, a TMS client, and a new, powerful web inspector for UI automation. 

We’re launching a public preview of JetBrains Aqua so everyone can try it out and influence the design. You can find out more about the preview at the end of the post.

JetBrains Aqua is an intelligent, context-aware IDE that understands Java, Kotlin, Python, JavaScript, TypeScript, and SQL and provides intelligent coding assistance for each of them.

Like other JetBrains IDEs, Aqua checks the quality and validity of your code with on-the-fly inspections. If issues are found, the IDE will suggest context actions to help you solve them. Click the light bulb icon (or press Alt+Enter) to invoke a context action. Take advantage of language-aware code completion, error detection, and on-the-fly code fixes!

Use smart search to jump to any class, file, symbol, IDE action, or tool window. To use it, press Shift twice and start typing the name of whatever you are looking for.

Make the most of the IDE’s code intelligence with safe Rename and Delete, Extract Method, Introduce Variable, Inline Variable or Method, and other refactorings. Language and framework-specific refactorings help you make project-wide changes.

Unit test frameworks

Create and run your tests with coding assistance and a GUI-based test runner. With JetBrains Aqua you can write, run, and debug your unit tests using JUnit, TestNG, Pytest, Jest, Mocha, and other popular frameworks. Reviewing the test results inside the IDE allows you to easily navigate in a tree view and to the test source.

UI automation

New Project wizard

Aqua can generate a new UI test project for the JVM stack, allowing you to specify the JDK, build tool (Maven or Gradle), test runner (JUnit or TestNG), and language from the New Project wizard.

Code insight 

Aqua provides rich support for the Selenium API and Selenide, offering code insight for the CSS, XPath, and JavaScript fragments used in the Selenium API and many other libraries for UI testing. 

Page Object templates

When following the Page Object pattern, the IDE helps you create and maintain new page object files from the New File menu and respects the selected page object pattern when adding locators.

Web Inspector

The embedded Web Inspector allows you to view web applications in Aqua and capture page elements required for automated tests. Aqua generates a unique CSS or XPath locator for the selected element on the web page and helps add it to the source code. If there is more than one locator that uniquely identifies the same element, Web Inspector will suggest all possibilities.

While maintaining tests, Aqua helps you verify existing locators. Just validate your CSS selector or XPath with Web Inspector and check whether the locator identified the element you want.

When Web Inspector is active, CSS and XPath code completion suggests and highlights locators for the most important web page elements. 

Web Inspector can also be undocked to a separate window for a better experience on large screens.

API testing and environment setup

HTTP client

When developing a web service that sends and receives HTTP requests, you can easily create and edit requests in Aqua’s built-in HTTP client and receive extensive code assistance, including code completion, highlighting, refactorings, and more.

Docker

With Aqua, you get access to your Docker containers, allowing you to run and debug them, download and build images, and run multi-container applications.

Database

JetBrains Aqua does not require any extra tools to prepare your application data. You can seamlessly handle multiple databases, develop SQL scripts, and perform low-level data assertions right in the IDE. Aqua provides connections to live databases, runs queries, exports data, and allows you to manage schemes in a visual interface. This means you can access Oracle, SQL Server, PostgreSQL, MySQL, and other databases from the IDE.

TMS 

Tests usually contain links to issue trackers and TMS (test management systems). To make it possible to include them, developers use reporting libraries, such as Allure Framework, or built-in test framework mechanisms, such as Serenity BDD. We have added support for the annotations of these libraries, and the IDE allows you to open issues or TMS cases in a web browser just by clicking on the issue IDs.

Aqua can connect to external TMS systems, such as TestRail, making the tests more accessible from the IDE. It supports browsing test suites and case hierarchies, as well as navigation for TMS items. It also generates unit tests for selected test scenarios and helps you find non-automated test cases or obsolete test methods.

Aqua also supports the experimental “Local TMS” approach, an agile way to store and manage your test data. The local TMS stores test data as a collection of t.md and r.md files in the project. This approach allows for branching, versioning, reviewing, and better integration with automated tests.

Building a complete IDE for test automation is a significant undertaking. During the preview stage we are still in active development and continuing to implement features and improvements, so some things might not work as expected. Please help us improve the product by sharing your thoughts about any features or missing functionality from JetBrains Aqua. Let’s build the best test automation IDE together!

You can download the latest preview build via the Toolbox App or our website.

Download Aqua

Please use this feedback form to share feedback or ask any questions you might have. 

Subscribe to our blog to receive news about the latest improvements, and be sure to follow us on Twitter!

Happy automated testing!

The Aqua team

Improved web page structure in the Page Object Editor

One of the biggest changes to the UI in this release is the reformatted web page structure. Now you can comfortably read the most important parts, such as the tag name, the ID, and applied CSS classes – all thanks to the text format highlighting.

Easy navigation via gutter icons

How easy is it to get back to page elements from the web page structure? Very easy! Now all you need to do is click on the gutter panel icon next to the page element you added to the code, and it will take you right to the web page element in both the web page structure and the browser window.

Page object naming from URL

When creating a new page object file, the wizard now offers an optional URL field. If the web address is inserted, the wizard automatically suggests a page object file name based on the link address. In addition to that, the inserted URL will also automatically load in the browser window when the Page Object Editor opens.

Automatic caret movement to the ends of code blocks

When adding new page elements to your code, the caret now automatically moves to the end of the added code block. This makes it easier to spot where the caret is located, so you can simply continue working within the code.

Create a new page object from the context menu

Whenever you type a new non-referenced page object class when working on an existing one, you can fix the unresolved code warning by simply navigating to the warning’s context menu and creating a new page object right from there.

Follow us on our Twitter account @JetBrainsQA and get more updates!

Selenium lets us interact with web elements through a convenient API. Selenide makes it handier by adding convenience methods and spares us from tedious setup. Every new technology strives to raise the bar and make web testing even more enjoyable. The value of such frameworks cannot be emphasized enough. They are force multipliers indeed!

Now that’s related to the code itself, but what about the tooling? Is there something that we can leverage to streamline the process even more?

Sure! As an IntelliJ IDEA user, you have an entire suite of tools at your disposal, and in this post we’ll take a peek at how we can generate Selenium page objects and test data when testing a web page.

Note: To use the features from this post, make sure you have Selenium (IntelliJ IDEA Ultimate) and Test Data plugins installed. The minimum version of the IDE is 2022.1.

Demo project

The examples below are based on a demo project that you can clone here: https://github.com/flounder4130/exciting-form.

Otherwise, you can perform the same steps using your own project and website of your liking. If you follow that path, the fastest way to set up all dependencies is through the wizard (File | New | Project | Selenium).

In our demo project, we have a simple server that responds with a sign-up form. To access it, start the Server run configuration and open http://localhost:8000/signup in your browser.

We got the page up and running – let’s test it!

Create a page object

If you use Selenium in your day-to-day work, you definitely know about the importance of page objects. This pattern adds structure to the test code, greatly improving its readability and maintainability.

IntelliJ IDEA’s Selenium support makes this step very easy. In the test root, right-click the package where you want to store the page object, then select Selenium Page Object.

Give the page object a name. This will open the embedded browser and the corresponding page object for it. In the browser, enter the website URL. After that, you can start picking the elements. When you select an element, IntelliJ IDEA locates it in the HTML.

It is as simple as that: You pick the elements you need and add them to the page object. The most appropriate selector type is determined automatically. However, you can be specific about that, and choose the required selector yourself. You can also customize the page object template according to the needs of your project.

All the elements that you add appear in the editor right away.

If you want to return to the browser later and modify the page object, just use the gutter icon.

The IDE recognizes the page_url comment and the current setup, ensuring the two tabs are always in sync. You can pick up where you left off at any time.

Generate Test Data

Now that we have web elements in place, we need data to use with them. Hopefully, you don’t need to browse the web in search of dictionaries and invent ways to combine them. Whenever you need test data, invoke the Generate action and choose the required data type. The generated string appears at the caret.

Generating massive CSVs or JSONs is not much harder. Just create a custom generator and use it in text files.

After you have set up a generator, you can create files containing an arbitrarily large number of entries with a couple of keystrokes.

Our project does not require sophisticated data types. However, there are many to choose from. If that’s still not enough, and you have something very specific in mind, you can generate any custom data with the help of regular expressions and compound data generators.

Write and run tests

That’s it! All you have to do is write a couple lines of code using your favorite testing framework.

We are not covering the coding part in this post, but the demo project comes complete with that, so you can refer to it.

Let’s run the tests:

Looks cool given that we barely even touched the keyboard, doesn’t it?

Summary

In this post, we did not go into much detail about the advanced features and step-by-step instructions. If you are interested in those, check out the documentation for Selenium support and test data generation. If you are curious whether your language or framework is supported, refer to this page.

Also, if you’d like to try something new, we recommend giving Local TMS a try. It is a simple format for storing test management data, which allows for closer integration with the codebase, versioning, and better workflow automation.

As always, we would love to hear from you. We are open to feature requests and feedback of all kinds. Let us know what you think!

Page Object Editor improvements

With the latest release, the Selenium UI Testing plugin got a huge improvement for its Page Object Editor. We’ve optimized the workflow and redesigned the UI to ensure that fewer distracting elements appear. You can instantly add page elements from the web page to the code on the fly, and then continue editing without leaving the Page Object Editor. You can also choose which selector type to use when adding a new page element to the code.

Now, when adding a new page element to the code, the Page Object Editor offers a specific selector that is suitable for use in the tool menu. If needed, you can choose other selectors from the drop-down menu (click the down arrow located to the right of the Selector tool). 

You can also select multiple elements and add them to the code with a single click. To make multiple selections, hold Command/Ctrl and click on all desired elements to select them. To select a range, hold Shift and click on the first and last elements of the range.

If you want to add multiple elements that satisfy a specific selector (such as XPath or CSS) or defined query, use the Multi-selector feature. Search functionality is also available.

New Page Object wizard

The new Page Object wizard allows you to choose the language and test automation framework when creating a new page object class. We also made the wizard available at all points in your code where you have a Selenium library dependency. 

If you want to try out our automatic page object generation with different frameworks and customized templates without creating a new file, there is a special playground mode available via Tools | Open Selenium Page Object Playground. 

Python support in Page Object Editor

We’ve added support for the Python language, which means you can now easily add new elements to the Page Object class. Also, a gutter icon will appear when the Page Object Editor detects an existing Python Page Object class if a Selenium library is available in the current Python module.

QA Tools are on Twitter

Follow us on our QA Tools Twitter account – full of tips & tricks, how-to’s, and news from our team! 

We would like to bring to your attention a new page dedicated to the Test Automation Kit – a set of tools for QA and Test engineers. Here you can find an overview of the tools and links to various resources you might find useful.

We also have a brand new Twitter account dedicated to sharing our QA Tools news. Check it out and be sure to follow @JetBrainsQA. 

Selenium UI Testing

A huge update brought support for UI test automation in Selenium – the visual editor can now help you to maintain existing page object classes. Previously, it was only possible to generate new page object classes, but now you are even able to update the existing page object classes directly without a visual editor. IntelliJ IDEA will detect page object classes automatically and indicate them with a corresponding icon on the gutter panel. By clicking on that gutter panel, the user can open a visual editor and grab new elements to be added to the page object class.

We added an action item to the context menu of the unit tests root folder to generate a new Selenium Page Object with the help of our visual editor.

Selenium and Zelenium frameworks with Python templates are now supported.

Furthermore, we made a small update to the UX/UI by redesigning a few feature icons and implementing functionality for persistent Page Object Editor language and framework settings.

There is even more good news for Selenium users – in the New Project wizard you can find Selenium 4, which is now officially supported.

Selenium UI Testing plugin

Test Management

Test Run Hierarchy

We implemented support for multilevel test runs. You can now create multiple child test runs for specific functionality domains or types of testing. Each parent test run aggregates the results of the child test runs and provides summary statistics from all sub-related test runs.

Shared steps

If you choose to manage test cases in Markdown files using our “Local TMS” feature, you will be able to easily declare test steps and share them among multiple test cases. Shared steps are declared as a regular Test Case with a unique numeric ID. You can refer to that test case in other test cases and IntelliJ IDEA will substitute those referenced test case steps when generating previews, test runs, or code templates for an automatic test.

Test Management plugin

Test Data

The newest plugin from the Test Automation Kit got a few minor bug fixes, but also a useful feature in multiple data generator settings. Now you can modify the prefixes, suffixes, and delimiters with a multiline definition.

Test Data plugin

Please let us know what you think! We really appreciate your feedback, and we encourage you to continue to share your thoughts and suggestions with us. You can reach us on Twitter, using our issue tracker, or right here in the comments. Don’t forget to subscribe to our QA blog!

If you have any issues, don’t hesitate to let us know in our issue tracker – we’ve made customized links with predefined settings for each plugin: Selenium UI Testing, Test Management, Test Data.

Follow @JetBrainsQA

If you want to try this approach in your team, all you’ll need is IntelliJ IDEA Community Edition and the Test Management plugin.

Prepare test cases

Let’s imagine we are working in an Agile team and our developers are actively working on a new feature in a dedicated branch. As QA engineers, we need to prepare test scenarios and checklists in advance to be ready for testing.

The Test as Text concept requires us to keep our test cases in a simple, text editor-friendly format and, if possible, use a version control system. Let’s choose a folder where we want to add test scenarios and create a new test case. 

From the context menu, select “New Test Case” and provide a name for the test case. Our IDE will create a markdown file with some example text.

While the content of the file is pure Markdown, notice the unusual extension: .t.md. That extension indicates that the purpose of this markdown file is to store test scenarios.

As we can see from the example text, the format of the file is pretty simple. The Markdown header describes the name of the test suite (checklist), and the bullets are the names of the checks or test cases. If we want to decompose the test case into steps, we can do so using a nested bulleted list. IntelliJ IDEA will help us distinguish between test cases and steps by marking each with a corresponding gutter icon.

Let’s define a couple of test cases that will describe the new functionality being developed in this branch. We can also declare some tags and meta information for these tests.

As soon as we finish, we can commit our results to the VCS to share them with the rest of the team.

We can browse and filter all our existing and newly created test cases in the TMS tool window. To quickly navigate to the test scenario, we can use Search Everywhere and type the name of the test. To narrow the results we can use the /tms prefix or use Navigate | TMS item from the main menu.

Perform checks and store results

Now that we’ve created test cases for our new functionality, we can perform the checks as soon as the developers are ready.

From the context menu, select New Test Run (in our example we will do it in the folder where we store our test cases) and provide a name for it. Select the tests that we want to perform and confirm the selection.

The IDE will create a markdown file, but this time with the “.r.md” extension, indicating that the file is used to store the results of the performed checks.

The steps for the test scenarios are copied to the test run, and by default each scenario has the “unknown” status. The name of the test run should be formatted as a header in Markdown. IntelliJ IDEA marks each test and its results with gutter icons and highlights them in the editor.

As soon as we perform a check, we can make a record of the results and replace the “unknown” status with the standard “success” or “fail”, or use any other word we prefer as the status indicator. We can use any status we’ve agreed on in our team with zero configuration. Sometimes we have to step away from the test scenario, or we want to indicate details of actions that were performed. We can do this by altering the description of the steps in the corresponding test.

Our test run also appears in the TMS Tool window. When we finish, we can commit the results of the checks (the test run file) to the VCS and share them with the team.

Create an automated test

As we approach the final steps of the feature implementation, it’s time to automate at least some of our tests.

There are multiple ways that IntelliJ IDEA can help us with that. Let’s open the unit-test class where we want to add a new automated test.

After that, find the test case we want to automate in the TMS tool window. To see all non-automated tests, open the Filtering dialog and choose to show all test cases that are not referenced from code. As we haven’t automated our newly created test cases yet, we will see all of them in the TMS tool window.

Copy the test you want to implement using the shortcut or the context menu, then paste it in the unit test class.

IntelliJ IDEA will insert a test function template with the corresponding name and all of the preconfigured Java annotations. The body of the function will contain the steps of the test scenario as a code comment. Now we are ready to implement our automated tests.

This test scenario is no longer displayed in the TMS tool window, as it is now referenced from the code.

We can navigate to the declaration of the test scenario by clicking the reference in the comments or our custom TmsLink annotation. When the implementation of the feature is completed, our team will merge it to the main branch.

The list of test scenarios and performed checks can be viewed as a quality report for the new feature, and we can use test scenarios for future regression checks and test automation.

How to try it

You just need to install the Test Management plugin to your JetBrains IDE. You can browse and edit test cases in any supported JetBrains IDE, but integration with unit-tests is currently available only for Java, Kotlin, and Python (IntelliJ IDEA Community Edition 2021.2 and PyCharm Community Edition 2021.2).

Please see the official documentation to learn how to enable Local TMS (Test as Text), configure custom Java annotations and Python decorators as TMS links, and adjust code generation templates.

The latest version of the Test Management plugin supports test suites, sub-suites, checklists, and test cases with steps. You can specify tags and metadata (key values) to organize and filter TMS elements. You can also assign a unique number, which the IDE will check, to any test case or checklist item, allowing you to reference it from the code.

Test Suite (.t.md) and Test Run (.r.md) files can be stored in any folder in the project. However, we recommend using a single directory for your local TMS data.

Conclusions

The Test as Text approach helps us maintain test scenarios in an Agile way, as we can design tests and perform checks while the feature is being developed. Because everything is stored in the same project under the VCS, we can see the change history and developers can access the test scenarios for debugging. This approach suits Agile teams and increases the efficiency and transparency of testing.

If you would like to participate in an interview to share your feedback and help us improve our tools for quality assurance, please sign up here. To suggest new features and report bugs, please create an issue in YouTrack.

Sign up and help us improve our tools

Test Data

Introducing Test Data – a new plugin in our Test Automation Kit. Those who have used the Test Management plugin might have already noticed many useful actions in the Generate menu.

In this release we’ve extracted those actions to a separate plugin and reworked the settings, so it’s even easier now to create a custom pattern for data generation.

Our random test data generation engine supports predefined vocabularies, can generate data based on regular expressions, and even supports complex formats such as JSON and XML.

The Test Data plugin is available for all JetBrains IDEs.

Test Management

The Test Management plugin got a significant update and now supports Python along with Java/Kotlin. You can also link your Python tests with the test cases from the TestRail test management system.

Declare your unit-test decorator function in the settings and the IDE will use it to link your automated tests with TMS entities. The Test Management plugin will help you track invalid links or show which test cases are not automated yet.

When you copy and paste the test case from the TMS tool window to a Python file, a stub function will be generated with all the required attributes. The template for the method can be easily customized and shared with your team.

The Test Management plugin is now available for free JetBrains IDEs like IntelliJ IDEA Community Edition and PyCharm Community Edition.

Selenium UI Testing

The Page Object Generator (POG) is a smart tool that comes with the Selenium UI Testing plugin. It helps you inspect the DOM and generate optimal XPath and CSS selectors for particular elements.

Multiple templates and test frameworks are supported, including Selenium, Selenide, Atlas, JDI Light, and FluentLenium.

The logic of how these selectors are generated was improved for this release. The POG tries to suggest the shortest possible selector wherever it is possible. If the shortest path doesn’t uniquely identify the selected DOM element, the POG inspects the parent and child elements to build a path.

All code templates for the POG are now available for customization. 

The POG is a part of Selenium UI Testing plugin and is available for our paid IDEs.

Day: Friday
Date: May 28, 2021
Time: 5:00 pm – 6:00 pm CEST

Session agenda

End-to-end testing is a common testing methodology where the objective is to test how an application works by checking user scenarios from start to finish. Usually, it is not that easy to write and maintain these tests. Fortunately, we have Selenium, a rock-solid ecosystem where you can find almost everything for UI automation, both for web and mobile testing.

In this live stream, we will talk about modern approaches to UI test automation with Selenium and Java. Let’s see if setting up e2e tests is easy or not, and how we can do it better.

Asking questions

If you have any questions on this topic, you can submit them now or during the live stream. To ask your questions now, post them as comments to this blog post. To ask them during the live stream, please use the chat window.

The host will try to answer all of your questions during the session. If we run out of time, we’ll post the answers to any remaining questions in a follow-up blog post.

Your presenter and host

About the presenter:

About the host:

See you at the live stream, and happy developing!

Browse

Once you’ve installed the Test Management plugin, you will have access to the new TMS tool window in IntelliJ IDEA Ultimate. Here you can create a new connection to a TestRail server and select a specific project to sync.

The IDE will automatically sync the list of test cases and test runs, including all the necessary metadata. You can browse the hierarchy of TMS items, such as suites, test cases, and active test runs. A preview window will display additional details about the selected element.

TMS projects often have their own unique properties and parameters. The Filter action in the TMS tool window allows you to filter items according to these custom properties. Code completion in the filter window helps you select from all available values for each property.

The Filter action makes it easy to browse relevant items, for instance, non-automated tests related to a specific subsystem.

Navigate

As soon as the IDE is synced with the test management system, all imported items (cases, plans, and runs) can be found using Search Everywhere.

If you want to search through test management system items, you just have to use Navigate | TMS item from the main menu or type the /tms prefix in the search query.

All test management items can be mentioned in source code comments. Clicking the element will display a preview popup with detailed information about it.
Any custom Java/Kotlin annotation can be specified as a special TMS element reference. A method with these annotations is treated as referencing a TMS element, allowing you to easily navigate to it and, more importantly, find usages of it.

Generate

The New Test From Test Cases action allows you to generate unit tests from a selected set of test scenarios for Java and Kotlin. By default, test classes and methods are generated with “steps” inserted as comments into the method body. Thanks to the rich templating support in the Intelli Platform, generated test templates can be easily customized to fit each team’s needs.
If you copy a test case to the clipboard, IntelliJ IDEA Ultimate is smart enough to paste it as a test method in Java or Kotlin following the same template.!

Analyze

If you have set up custom annotation classes as references to TMS elements, the Test Management plugin makes it possible to analyze which test cases are referenced from code and which are not. This makes it easy to find all test cases that need to be automated.

Also, it is very important to find possibly outdated or obsolete automated tests that point to non-existent test cases. The Find All Unresolved TMS Links action will show you all the test methods that have broken links to TMS elements.

How to try it

To give these features a try, make sure you are using the latest version of IntelliJ IDEA Ultimate 2021.1 and install the Test Management plugin from Test Automation Kit.

We would appreciate your feedback! Feel free to share your thoughts in the comments section to this post or on Twitter, and please report any bugs you encounter to our issue tracker.