What our R&D team needs to deal with most is various new requirements. The faster and faster software update speed also makes the whole system more and more complex, which makes the testing work face a huge challenge. Testers must communicate with developers, determine the scope of testing, and obtain the latest interface use case data in time to verify functions. However, due to frequent changes in requirements, the test scope cannot keep up with the update speed of the interface in time, resulting in many potential problems being missed and affecting the quality of the software.
The traditional static test mode greatly affects the work experience. As a professional API interface management platform, Apifox provides a series of visualization and automation functions, which can effectively help testers deal with these challenges .
For example, we are developing an online medical question-and-answer platform, which provides hundreds of service interfaces. In order to fully test all functions, testers need to spend a lot of time writing and debugging test cases, and also need to manually write automated test scripts. But if we use Apifox, we can quickly generate test cases that match the core logic of the interface on the easy-to-use visual interface management page, arrange the order of interface tests by dragging and dropping, and generate automated test strategies . Even if the interface changes, the system can adjust the test cases in real time. In addition, Apifox also provides CI/CD embedded commands to help the team achieve fully automated test execution and regression .
Jointly and efficiently maintain automated test cases
In the same company, different R&D teams use different technologies and tools, resulting in data isolation is the norm. The most common situation is that the interface function is updated, but the interface document is old and outdated, which makes testers spend a lot of time on data confirmation and synchronization. They often need to confirm the latest interface information with development engineers, which is very laborious.
After the developer defines the interface document of the new function on Swagger, the tester needs to manually copy the parameters and write the expected response result, and then use the test tool to send the request and compare the results. Whenever product requirements change, the interface needs to be adjusted, which makes testers miserable. Because they need to spend a lot of time manually comparing interface documents and test cases, and then work overtime after confirmation to send interface requests one by one and verify the results, in order to catch up with the release deadline. How can this collaboration gap be effectively resolved?
In Apifox, development only needs to maintain interface documents in "Interface Management", and tests can easily import use cases in the "Automated Test" module without repeatedly checking the data. Click the synchronization button to seamlessly connect the old and new data, get rid of the boring work of data synchronization, and devote yourself to the core testing process and create new value .
Taking the scenario of " verifying whether the registration and posting process of ordinary users on the platform meets expectations " as an example, testers can directly import user-related interfaces in "automated testing". When importing the interface, specify the synchronization method as "manual synchronization" or "automatic synchronization", both of which can make the data synchronization process more efficient.
Automatic mode enables real-time synchronization of interface documents and test scene data. When a developer modifies the request method in the "User Unfavorite" function interface on Apifox, all changes will be immediately synchronized to the test step to ensure that the data in "Interface Management" and "Automated Test" are consistent.
If you are worried that the existing test data will be affected after the interface is developed and updated, you can select the synchronization mode as " manual mode " to grasp the timing of synchronization. The test can first confirm whether the data changes are correct, and then easily click the synchronization button to seamlessly import the latest interface data into the test. In this way, you can get rid of boring data processing, and focus more on the interface testing work itself, and realize the real dynamic collaboration between automated testing and interface management.
Simulate real-world scenarios to arrange API test sequence
When accessing the medical information question-and-answer platform, you usually need to follow the following process: register-browse/create questions-leave feedback . Sometimes, when we test each interface individually, it responds normally. But when we chain them together to perform tests, we run into some tricky problems. For example, after registration, the system did not return the correct Token value, causing all subsequent operations that required login to fail.
In order to better simulate the production environment, testers need to clarify the dependencies between interface functions. For example, which functions require users to register first before they can be executed. Only in this way can we truly restore the user scenario and fully verify the stability of the system.
In order to improve test efficiency and coverage, test execution logic can be flexibly arranged, such as adding conditions such as grouping, looping, conditional branching, and waiting time to test steps . Grouping can organize related use cases by module; looping can simulate repetitive processes such as user browsing or refreshing; conditional judgment can verify different response paths; reasonable waiting time can simulate more realistic user behavior.
The combination of these execution control measures can realize comprehensive automatic verification of business scenarios. It not only saves a lot of manual operations, but also can be executed continuously and with high intensity, which has a good guarantee for the quality of the system.
Associate External Security Isolation Data Driven Tests
To protect security, developers should avoid filling in any sensitive information in interface documents. If user-related API keys, database connection strings, etc. are involved, they should be extracted into independent external security files for unified management. This is a challenge for testers, because it means that in some cases, data needs to be imported one by one into the test case for testing.
In Apifox, testers only need to add external data sets in the "test scene", and use the environment variables in the interface in combination with external data sets to dynamically reference sensitive data such as keys and tokens in the data set . When the test scenario is running, the system will run all the data sets in the data file in a loop, extract the data in the data set and assign them to the corresponding variables.
Multiple sets of test data sets can be saved in a test scene, and the external data to be used for this test can be selected in the "Test Data".
Easily develop an automated testing strategy
Before officially running the automated test, the tester also needs to ensure the following configurations:
- Sequence of test steps
- operating environment
- Cycles
The change and switching of the environment will always bring a lot of workload to the testers. Developers use test environment A locally, while testers need to use test environment B for overall system testing . Both domain names, configurations, and data are different.
Every time a certain configuration is changed, a test environment needs to be re-established, and the testers are busy, just to repeatedly migrate the overall data and reconfigure the automation tools.
In the automated testing function of Apifox , testers can switch the operating environment with one click without changing the environment frequently, thereby changing all pre-URLs in the test steps in batches, without repeatedly adjusting test parameters and modifying test cases. Combined with the "scene instance" function, it is also possible to modularize and save data such as test cases with one click. In the advanced settings, you can also specify parameter information such as global cookies to simulate real requests as much as possible. After confirming that it is correct, the tester can click the "Run" button to start the automated testing process.
Scenario instances can reuse test parameters
In the test scenario used by a medical information question answering platform, the process arrangement is basically fixed. However, in the actual test, there are different servers (test environment, formal environment, etc.), different account types (doctor users, ordinary users) , and the differences in these operating parameters will affect the final operating results. By saving multiple sets of running configurations through the **"Save as Scenario Instance"** function, you can run the test scenario with one click according to the test requirements, and produce test results that meet the requirements, without the need to frequently switch operating parameters to perform test tasks.
For example, the following scenarios exist:
- The formal environment needs real data, and the test environment needs simulated data
- Physician user scenarios require additional independent data to validate differences
In Apifox, we only need to set multiple scene instances, and achieve efficient automation through parameterization and reuse. It can not only simulate different data, but also perform verification repeatedly to ensure the quality of the test.
Integrate into automated workflows within your team
Many R&D teams have established continuous integration/continuous deployment (CI/CD) automation workflows and regularly execute test scenarios to ensure stable system operation. Every time a new feature is released, automated regression testing is done to avoid potential risks. However, in order to implement automatic regression testing after each release, testers need to manually invoke the CI process of the test script. Not only is this time consuming, it also requires constant tuning of the pipeline configuration based on the test cases.
The command line tool (CLI) provided by Apifox has many built-in efficient testing capabilities, which can be better integrated into the team's existing automation workflow. Testers can generate configuration code for Jenkins and Github Actions with one click in the Continuous Integration module.
Add embedded code in the command line editor of Jenkins or Github Actions, and the test scenario in Apifox will be automatically executed after running the continuous integration task.
Visualization of test results
After the automated test process runs, an intuitive test report will be output. Testers can visually see the pass rate and failure reasons of the interface here. The test report supports exporting in HTML format. After the test task is finished, click the "Export Report" button to trigger an automatic download.
In the test example of the medical information question answering platform above, the powerful automated testing function of Apifox can help testers say goodbye to repetitive manual testing and complete testing tasks faster, thus saving a lot of time while maintaining quality . The same tool brings higher consistency, makes the stability and repeatability of the test reach a high standard, and can well achieve the goal of "quickly reproducing software defects". You can also learn more about how to use the automated testing function in the help documentation to help you implement more efficient testing projects.