A practical review of Testiny Test Management Tool – a powerful one-stop solution to quickly manage all your Test Cases and Test Runs with its user-friendly interface:
Testiny is a test management tool to manage all your test cases, test plans, and test runs, as well as import and analyze the results from your test automation tool. It further integrates with other tools like issue trackers for requirement and defect management (e.g. Jira) or any CI/CD pipelines via their CLI tool.
Table of Contents:
Testiny – A Modern & Dynamic Test Management Tool
Exploring Testiny: Core Capabilities
- Test Management
- Test Case Management
- Test Plans
- Customization (Custom Fields, Test Case Templates)
- WYSIWYG Editor
- Import/Export, PDF Reports
- Issue-Tracker Integration for Requirements and Defects
- Jira (Server and Cloud) incl. Jira Add-On
- GitHub
- GitLab
- Azure DevOps
- Redmine
- Asana
- Many others
- Test Automation via CLI or API
- Security & Compliance
Testiny – Comprehensive Hands-on Review
To follow along with this walkthrough, you can start a free Testiny trial version here.
#1) Getting Started With Testiny Test Management Tool
We begin by creating a new account, and the sign-up process is straightforward, requiring no credit card information. When you sign up, you automatically get enrolled in the free trial, and you have access to all features.
Testiny ensures a user-friendly experience by guiding the entire application, making it intuitive for users to take their initial steps. For example, in the screenshot below you have two options after signing up: either create a new empty project or add a demo project.
We will create a demo project to explore the main features quickly.
#2) Test Cases, Plans, and Runs
After creating the demo project, let’s go to “Test cases”.
Testiny efficiently organizes test cases within folders in a hierarchical structure. Organizing tests with folders is the best method because it provides a clear structure and is easier to maintain. By using a simple drag-and-drop action, users can relocate test cases to different folders.
Clicking on a test case opens a side panel on the right to view its details. Creating individual steps with associated results is very easy and the UI of the steps is also very clear. The rich text editor offers a range of formatting options such as bulleted lists, bold, italic, tables, in-line images, links, and more.
Notably, Testiny incorporates convenient features like marking text as “copyable,” streamlining tasks like copying credentials to your clipboard with a simple click. Finally, you can also attach files or images to test cases.
The History tab captures all changes made by you or others, providing a transparent record of modifications over time.
It facilitates linking test cases to requirements within the integrated tool. A notable feature is the ability to track defects linked to the test case in test runs, offering a comprehensive overview of any issues encountered during testing. For additional details on that, please refer to the section Issue-Tracker Integrations below.
But first, let’s continue with exploring test plans. I selected the test plan “Smoketest” that already exists in the demo project and switched to the tab “test cases”. Here, as shown in the screenshot, we can see and define queries to add test cases to test plans.
In this demo test plan, there are already two queries. The first one includes the condition “priority equals ‘high’”, meaning that all test cases that satisfy this condition are in the plan. This “dynamic query” is an amazing feature, as it keeps the test plan current. If I create a new test case and set its priority to “high”, it will automatically be added to this test plan.
The second query is static, that is I can also select single test cases that I want to add to my test plan. Below the queries, we can see the list of test cases in this test plan. To create a test run with these test cases, we click “Create test run”.
Testiny immediately creates a new test run shown in the screenshot below and automatically opens the respective page. All the test cases from the test plan above are in the run. We can then assign other team members to the test cases, execute the tests set a result (Passed, failed, skipped, or blocked), and attach a screenshot of a failed test or comment on it.
However, we cannot set a result separately for each test step. We can directly create defects if an issue-tracking tool is configured in Testiny. More about that is in the section Issue – Tracker Integrations below.
After executing all tests and setting a result, let’s see what we can do with the finished test run. In the actions menu, we can “close test run” to make it immutable and archive the results, so that no one can change it anymore. We can also click “create report” to create a PDF report or “export the test run” as a CSV or Excel file.
If you go back to the test runs’ test plan, you can see the results of the run in there too. Over time, if you execute test runs from the same test plan, you’ll have a nice historical view of how your tests have performed.
Suggested Read => Difference Between Test Plan, Test Strategy, Test Case, Test Script
#3) Issue-Tracker Integrations
Let’s explore the previously mentioned issue-tracker integrations. We go to “Settings” and then “Integrations”. Here Testiny offers a list of tools they integrate with like Jira, Azure DevOps, GitHub, GitLab, Asana, Trello, monday.com, etc.
To test this feature, we’ll add an integration to the Jira Server, as shown in the screenshot below. Optionally, you can also install their JIRA app to see the linked test cases inside JIRA.
After adding an issue-tracker integration, you can see the Requirement and Defect Tabs in the test cases and test runs details tab, as shown below.
You can either create a new issue or link an existing one. In the screenshot on the left, you can see the create dialog, where you can choose the project, and the issue type, define a title and a description, and optionally add other fields or add test steps and comments to the Issue description.
After creating the issue, you can see what a linked issue looks like. You can click the link to get to the issue and you can see the current status (“To Do”) of the Jira issue. The overview tab of the test run also shows the defects and allows you to add them to the PDF report.
Finally, you can also link an issue as a defect as shown on the right, where you can search and go through existing issues.
The issue-tracking integration for Jira works very well in Testiny and ensures a seamless working experience. We didn’t test the other integrations, but it works similarly for GitLab, GitHub, Azure DevOps, and Redmine.
Also Read => JIRA Bug Tracking: Defect Life Cycle in JIRA
#4) Settings & Administrations
Now let’s explore the settings that we haven’t seen so far.
In the “organization” settings, you can configure single sign-on and define behavior on an organization level, for example, if editing test results is allowed at all or just within a grace period. Those settings can also be configured per project and user roles can be given per project, which allows for fine-grained configuration if multiple teams are using the same organization.
You can also create and manage API Keys here in the settings, and again create API keys just for single projects, set an expiration date if wanted, and define write or read-only permissions.
In the settings, you can also find the Audit Log, which records the actions of every user. You’ll see when users have logged in, changed test cases or results, changed any settings, or created/linked defects or requirements.
Last but not least, you can also create Custom Fields for your test cases. As seen in the screenshot below, Testiny has some predefined fields in there, for example, “Priority”. In the panel on the right side, you can see all the settings. Here we could add our values or rename them.
We can also create our custom fields. We can define the name, and the type (numbers, URLs, multi-selects), make it required to be filled out and configure it per project. This is a really powerful feature, as you can adapt and add the test case fields to your needs to write your tests and store any additional information you may need.
#5) Importing Test Cases & Test Automation
We generate a fresh project by selecting the dropdown menu next to the project name in the toolbar. Within this newly created project, all sections are empty and prompting us to navigate to the “test cases” section. Here, as shown in the screenshot below, Testiny presents a range of options for adding test cases. Users can opt for manual creation.
Alternatively, they can use the import wizard to import test cases from an existing CSV or TestRail XML file, or they can use the CLI or REST API to import test cases and results from automated test runs.
In our next step, we’re going to import some test cases from a CSV file. I’ve downloaded their sample CSV file added two columns “Priority” and “MyCustomField” and drag & drop it into the import wizard. In the screenshot below, we can see that Testiny attempts to automatically map our test cases to the test case format in Testiny.
In the following screenshot, we can see the field mapping and a preview of the test cases that are going to be imported.
If you want to create new fields to not lose any information, you can click “Add a new field to map to” to create a new custom field. Otherwise, we click “OK” and then “Import” and Testiny imports the test cases as shown in the preview. Importing existing test cases works like a charm, and the CLI works in the same way, so uploading automated test results is not a problem at all.
Pricing
Testiny charges $17 per user monthly or $14.50 with an annual subscription and offers a volume discount on its website.
They provide a viewer license for an amazing price, a great option for team members who want to see and analyze the results or leave a comment. As a result, Testiny offers a great price/performance ratio for a test management tool.
Conclusion
Testiny stands out for its budget-friendly pricing in the mid-range, excellent usability, and manageable learning curve. It offers robust test management features, and a fantastic integration with issue trackers (tested with JIRA), and importing tests is as easy as possible.
While the platform excels in supporting new users with great usability, integrations, and adaptable settings to meet diverse testing requirements, there are areas for improvement like reusable steps, results per step, and better documentation for collecting automated test results.
Hopefully, these features will be added soon as their team is actively working on Testiny and will be releasing new versions regularly.
In conclusion, Testiny is a highly recommended option for teams looking for an affordable yet feature-rich test management solution that integrates well with other tools and testing processes.
If you are still managing test cases using spreadsheets or if you’re unhappy with your current tool, I’d suggest giving Testiny a try to see what you can achieve for your project.