The record of developing an excellent test engineer, after four years of mediocre work, "I" is going to advance...

Contents: Guide

foreword

How to become a good test engineer?

1. From simple testing to project quality assurance work

Testers generally write and prepare test plans and test cases during the development phase. In the testing phase, we usually do functional testing first, and when the project functions are basically stable and there are fewer bugs, we start to do compatibility testing, performance testing, and security testing.

The compatibility test ensures the compatibility of the product in multiple browsers and APPs under different models; the
performance test ensures the service ability of the product under the large traffic of a large number of users;
the security test can discover the hidden dangers that the product may be attacked .
After completing these tests, the personnel release the quality report and the product goes live.

However, excellent testers need to expand the field of testing upstream and downstream, put themselves in the role of "quality assurance", and promote the entire project team to ensure quality together.

The upstream work includes: when the product is just established and the requirements are confirmed, the testers will participate and carefully review the requirements to see whether the requirements are complete and whether there are any loopholes. The cost is the least for the group.

In this link, testers can often find many loopholes in requirements by virtue of careful deduction and divergent thinking, which improves the overall efficiency of the project.

In addition, after the testers complete the test plan and test cases, they will invite developers and planners to review the test cases. A thorough analysis of the requirements can often find many loopholes in the requirements, which is also an effective link for early detection of the loopholes in the requirements.

We know that the quality of the code is guaranteed by the development in the final analysis. The work done by the test is only to find bugs and let the development fix them. If one vase is perfect at the beginning, and the other vase looks more perfect after various repairs, which vase do you think is better? The first vase, of course.

Therefore, testers should stand on the standpoint of quality assurance, find ways to communicate with the project team, provide tools for development, and let the development do a good job in quality assurance.

Some more feasible ways are:
provide some manual use cases for development self-test;
provide some automated interface and UI test code for development self-test;
deploy static code inspection tools, and promote development analysis and modification of found problems;
some have done Good projects have implemented continuous integration, and you can also try it.
The downstream work includes: after the product has completed the test, it is the release link, and the testers can also play a role in the release link.

If some versions have many revisions and the quality risk of going online is high, the testers will work with the product to formulate a grayscale release plan and implement it technically, so that the version will be open to a small number of users first. If a bug is found, the affected users It is also relatively small. After the bug is corrected, the user range will be gradually expanded.

In addition, excellent testers will mobilize other people in the project team to ensure the quality of the project.
For example:
promote development to conduct code review;
introduce smoke self-test process, let development first self-test and then submit to test for smoke test;
analyze bugs in the project team, let development improve self-test, reduce the number of bugs, etc.;
introduce planning , interaction, visual inspection during the test phase, and other measures.

2. Continuous integration exploration and automated testing technology research

The original meaning of continuous integration is to let the development automate the test every time the code is submitted. If the automated test finds a problem, the test case will fail, and the development will immediately discover the failure and modify the code.

To achieve continuous integration, there is a lot of work to be done: the first is the compilation process, all the compilation processes must be automated, and every time the development code is submitted, it can be automatically compiled.

After the compilation is completed, it is the link of static code inspection, and the problems of the code are checked through the tools of static code inspection, for example, the database connection pool is not released, the parameters do not match, and so on.

After the static code inspection is completed, it is the unit test. The unit test case is generally written by the developer or the tester, or the development and the test are jointly written to ensure the correctness of the internal function of the development. In a healthy automated testing solution, the proportion of unit test cases is the highest.

Then there is the interface test, which generally guarantees that the HTTP interface provided by the back-end development to the front-end development, the interface is generally relatively stable, and the use cases are easier to maintain, so the proportion of automation in interface testing can also be very high.

The upper layer of the interface test is the UI test for the user interface. Just like the manual execution of the tester, the UI automation test can operate the elements of the page and complete the automation. However, since the user interface is often refactored, we often control the scale of UI automation tests and only cover the main use cases.

Excellent testers can automate their work as much as possible and use continuous integration frameworks to improve work efficiency and quality.

3. Development of test related tools

Excellent testers will develop other useful and handy tools to improve work efficiency, such as automatic data generation, automatic report generation, and bug reporting tools.

In fact, in the final analysis, there is one sentence: the core job of testers is to ensure the quality of the project. The development of various testing processes, technologies, tools and platforms allows us to better guarantee the quality of the project.

The following is the most complete software test engineer learning knowledge architecture system diagram in 2023 that I compiled