Using GenRocket’s API to Maximize Code Coverage
GenRocket’s Test Data Automation (TDA) can be used to solve any test data challenge with self-provisioned test data that is integrated with test automation tools and frameworks. As data requirements change for different categories of testing, QA professionals can quickly configure the precise test data they need and generate it on-demand during test execution.
GenRocket TDA provides testers with total control over the volume, variety and validity of their test data. By configuring a Test Data Scenario to represent the database tables used by the application under test, testers can control the following test data elements:
- The volume of rows needed for application performance testing and load testing
- The variety of data fields needed for testing all combinations and edge conditions
- The queried production data needed to ensure authentic and accurate data values
- The relationships between key fields in the database to ensure referential integrity
- Synthetic data replacement of personally identifiable information to ensure privacy
These capabilities go a long way toward achieving the universal goal of maximized code coverage. However, there is another capability required for testing complex workflows that contain calculations and perform logic decisions.
With GenRocket’s API, dynamic test data can be generated in real-time that adapts to the application workflow by following pre-defined configuration rules and based on application business logic. The GenRocket API can be used to control any Test Data Scenario parameter. Here are some examples:
- Dynamically modify GenRocket components (e.g., domains, attributes, generators, and receivers)
- Use business logic to control test data during test execution (e.g., if this condition, then that data)
- Dynamically blend queried production data with any variation of synthetically generated test data
- Alter the loop account of a scenario to create hundreds, thousands, or millions of test records
- Refresh test data to its original state prior to use (restore the changes made by other applications)
In transactional environments, like an airline reservation system or a credit card transaction processing system, the data used by the application during testing can be fluid and subject to multiple program-driven changes. By using the GenRocket API, testers are able to provision test data for any workflow condition within the test case and dynamically load Test Data Scenarios to generate the required test data on-demand.
The GenRocket API allows a test case to dynamically modify its Test Data Scenarios to generate real-time synthetic test data (and queried production data) in all variations and combinations needed to test real world conditions and maximize coverage.
The GenRocket API allows testers to have complete control over the entire testing workflow as the software makes branching decisions, to determine what scenarios to load and what test data will be generated as the workflow test continues to run.
Here is a basic testing sequence using the GenRocket API:
1. A GenRocket Test Data Scenario is loaded
2. Test Data Scenario conditions are modified
3. Test Data Scenario is run, and test data is generated
4. A SOAP or REST request is made, and the response is saved
5. The test script parses the response and makes a decision for loading the next Test Data Scenario
6. The next GenRocket Test Data Scenario is loaded and is run
7. The system branches back to Step 2
To learn more about using the GenRocket API for testing workflows with dynamic test data, read this knowledgebase article (with example video).
If you would like to learn more about integrating GenRocket’s TDG technology with CI/CD pipelines and test automation tools, view our Solutions Sales Training Video
By using GenRocket’s API to control program-driven test data, testers can create and automate highly adaptable and dynamic test cases for any workflow. The simulation of any real-world scenario with dynamically generated test data allows developers to continuously improve algorithms and code performance while testers catch application defects before code is released to production.