According to my observation, the things that a good tester can do can include the following 3 points:
From simple testing to project quality assurance work,
continuous integration, exploration and promotion, and automated testing technology research and development of
test-related tools
1. Let’s talk about the first point, from simple testing to project quality assurance work
Testing, in a narrow sense, includes the following links:
test planning and test case writing - test execution - quality report writing
Testers generally write and prepare test plans and test cases during the development phase; during the testing phase , We usually do functional testing first, and then start to do compatibility testing, performance testing, and security testing when the project functions are basically stable and there are fewer bugs. The compatibility test ensures the compatibility of the product in multiple browsers and APPs under different models; the performance test ensures the service capability of the product under the conditions of massive user traffic and the security test can discover various hidden dangers that the product may be attacked . After completing these tests, the personnel issue a 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 approved and the requirements are confirmed, the testers will participate in it and carefully review the requirements to see if the requirements are complete and whether there are loopholes. At this time, the formal development has not yet entered, and the cost of modifying the requirements for the project team is The least. In this link, with careful deduction and divergent thinking, testers can often find many loopholes in requirements and improve the overall efficiency of the project.
In addition, after completing the test plan and test case, the tester will invite developers and planners to review the test case together. In this link, since the tester reflects the detailed test of each requirement in the test case, it is equivalent to re-examining the test case. After a thorough analysis of the requirements, many loopholes in the requirements can often be found. This is also an effective link for early detection of demand loopholes.
We know that the quality of the code is ultimately guaranteed by the development, testing does the work, and only finds bugs for the development to fix. If one vase is perfect from the beginning; another vase has been repaired and looks perfect. Which vase do you think is better? Of course the first vase. Therefore, testers should stand in the position of quality assurance, find a way to communicate with the project team, provide tools for the development, and let the development itself do a good job of quality assurance. Some of the more feasible ways are: provide some manual use cases to let the development self-test; give some automated interface and UI test code to let the development self-test; deploy static code inspection tools, and push the development to analyze and correct the problems found; some do Good projects have implemented continuous integration, and you can try it too.
Downstream work includes:
After the product is tested, it is the release stage. Testers can also play a role in the release stage. First, in order to deploy the test environment and study the technology of automated deployment, the testers can also automate the link of online deployment, which was previously required. The 2-hour deployment process is reduced to half an hour or less, and it is more accurate and reliable.
If some versions have many revisions, the quality risk of going online is high, 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 will be It is also relatively small. After the bug is corrected, the user range will be gradually expanded.
In addition, excellent testers will also mobilize other people in the project team to ensure the quality of the project, such as promoting the development of code review; introducing the smoke self-test process, so that the development will first self-test and then submit it to the test for smoke test; Analyze bugs in the project team, let the development improve self-testing, reduce the number of bugs, etc.; introduce planning, interaction, visual inspection during the testing phase, and other measures.
2. Research on continuous integration exploration and automated testing technology
The industry is talking about continuous integration, but what the hell is continuous integration?
The original meaning of continuous integration is to 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 find the failure and modify the code.
There is a lot of work to do to achieve continuous integration.
The first is the compilation link, all the compilation links should be automated, and the code can be automatically compiled every time the development is submitted;
after the compilation is completed, it is the link of the static code inspection, and the problem of the code is checked by the static code inspection tool, for example, The database connection pool is not released, the parameters do not match, etc.
After the static code inspection is completed, it is unit testing. Unit test cases are generally written by developers or testers, or written in cooperation with development and testing, to ensure the correctness of the internal functions 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 the HTTP interface provided by the back-end development to the front-end development. The interface is generally relatively stable, and the use case is relatively easy to maintain. Therefore, the automation ratio of the interface test can also be achieved 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 UIs are often refactored, we often control the scale of UI automation tests and only cover the backbone 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, it boils down to 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 ensure the quality of the project.
Original address: http://www.51test.space/archives/2157