CN116185869A

CN116185869A - Software testing method, system, computer equipment and storage medium

Info

Publication number: CN116185869A
Application number: CN202310234610.7A
Authority: CN
Inventors: 刘勇; 靳嘉晖; 王帆
Original assignee: Shandong Yunhai Guochuang Cloud Computing Equipment Industry Innovation Center Co Ltd
Current assignee: Shandong Yunhai Guochuang Cloud Computing Equipment Industry Innovation Center Co Ltd
Priority date: 2023-03-08
Filing date: 2023-03-08
Publication date: 2023-05-30

Abstract

The invention relates to the technical field of software, and particularly discloses a software testing method, a system, computer equipment and a storage medium, wherein the method comprises the following steps: constructing a mapping relation between a test case of software and a functional module; acquiring a target functional module and generating a test path based on the target functional module and the mapping relation; and testing based on the test path matching test resources. By the scheme of the invention, dynamic software integration test is realized, the pertinence and the coverage rate of the test are improved, and the quality problem can be effectively solved earlier and more efficiently.

Description

Software testing method, system, computer equipment and storage medium

Technical Field

The present invention relates to the field of software technologies, and in particular, to a software testing method, a system, a computer device, and a storage medium.

Background

In the test work of software, each code submission means that the software generates a new version, verification of functions and refreshing of performance indexes are required, and the time cost required for performing the full amount of functions and performance tests is not acceptable for daily construction. Typically, a fixed test case set is built daily for basic testing to ensure that basic functions are not problematic, but this approach cannot cover all over all the functional changes (even the introduction of new BUGs) and performance changes that result from each code modification.

Disclosure of Invention

In view of this, the invention provides a software testing method, system, computer device and storage medium, which automatically and dynamically generates corresponding testing paths for testing all daily code submissions according to the modified functional modules of codes and basic functions and performance cases, so as to improve the pertinence and coverage rate of the testing, effectively solve the quality problems earlier and more efficiently, and avoid the problems of low coverage rate, low effectiveness and the like caused by the original testing mode.

An aspect of the embodiment of the present invention provides a software testing method, which specifically includes the following steps:

constructing a mapping relation between a test case of software and a functional module;

acquiring a target functional module and generating a test path based on the target functional module and the mapping relation;

and testing based on the test path matching test resources.

In some implementations, generating the test path based on the target functional module and the mapping relationship includes:

acquiring a corresponding test case based on the target functional module and the mapping relation;

generating a test case set based on the acquired test cases, and configuring the priority and the test resource requirement of each test case in the test case set.

In some embodiments, configuring the priority of each test case in the set of test cases includes:

and configuring the priority of each test case in the test case set based on the test case attribute.

In some embodiments, testing based on the test path matching test resources includes:

and matching idle test resources based on the use case priority and the test resource requirements to execute the corresponding test use case.

In some embodiments, the target functional module is a modified functional module in a software iteration process;

the mapping relation between the test case and the functional module of the construction software comprises the following steps:

and constructing the mapping relation between the test case and the functional module of the software, and dynamically maintaining the mapping relation in the software iteration process.

In some embodiments, dynamically maintaining the mapping relationship during the software iteration includes:

in response to adding a new functional module in the software iteration process, judging whether the original test case covers the newly added functional module;

in response to the original test case not covering the new functional module, constructing a new test case and a mapping relation between the new test case and the new functional module, and maintaining the mapping relation based on the newly constructed mapping relation;

and responding to the original test case to cover the new functional module, constructing a mapping relation between the original test case and the new functional module, and maintaining the mapping relation based on the newly constructed mapping relation.

predicting test time required for executing each test case based on the historical test cases;

and matching idle test resources based on the predicted test time, the case priority and the test resource requirements to execute the corresponding test case.

In another aspect of the embodiment of the present invention, there is also provided a software testing system, including:

the construction module is configured to construct the mapping relation between the test cases and the functional modules of the software;

the generation module is configured to acquire a target functional module and generate a test path based on the target functional module and the mapping relation;

and the test module is configured to perform a test based on the test path matching test resources.

In yet another aspect of the embodiment of the present invention, there is also provided a computer apparatus, including: at least one processor; and a memory storing a computer program executable on the processor, the computer program implementing the steps of the method when executed by the processor:

and testing based on the test path matching test resources.

In yet another aspect of the embodiments of the present invention, there is also provided a computer-readable storage medium storing a computer program which, when executed by a processor, performs the following method steps:

and testing based on the test path matching test resources.

The invention has at least the following beneficial technical effects: the mapping relation between the test case and the functional module of the software is constructed; acquiring a target functional module, and generating a test path based on the target functional module and the mapping relation; the test is performed based on the test path matching test resources, so that dynamic software integration test is realized, the pertinence and the coverage rate of the test are improved, and the quality problem can be effectively solved earlier and more efficiently.

Drawings

In order to more clearly illustrate the embodiments of the invention or the technical solutions in the prior art, the drawings that are necessary for the description of the embodiments or the prior art will be briefly described, it being obvious that the drawings in the following description are only some embodiments of the invention and that other embodiments may be obtained according to these drawings without inventive effort for a person skilled in the art.

FIG. 1 is a block diagram of an embodiment of a software testing method provided by the present invention;

FIG. 2 is a schematic diagram of a software testing system according to an embodiment of the present invention;

FIG. 3 is a schematic diagram illustrating a computer device according to an embodiment of the present invention;

fig. 4 is a schematic structural diagram of an embodiment of a computer readable storage medium according to the present invention.

Detailed Description

In order to make the objects, technical solutions and advantages of the present invention more apparent, the following embodiments of the present invention will be described in further detail with reference to the accompanying drawings.

It should be noted that, in the embodiments of the present invention, all the expressions "first" and "second" are used to distinguish two entities with the same name but different entities or different parameters, and it is noted that the "first" and "second" are only used for convenience of expression, and should not be construed as limiting the embodiments of the present invention, and the following embodiments are not described one by one.

Based on the above objects, a first aspect of the embodiments of the present invention proposes an embodiment of a software testing method. As shown in fig. 1, it includes the steps of:

s10, constructing a mapping relation between a test case of software and a functional module;

s20, acquiring a target functional module, and generating a test path based on the target functional module and the mapping relation;

s30, testing is conducted based on the testing path matching testing resources.

It will be appreciated by those skilled in the art that the order of the steps of the method described above and illustrated below is not limited to the order listed, and may be modified as desired in practical applications, and that certain steps may be combined or omitted without departing from the scope of the present invention.

In particular, the invention can be applied to a dynamic test flow of continuous daily integration, but is not limited thereto, and the invention can be used wherever code modification of software is involved.

The following describes the inventive concept in connection with a daily continuous integrated dynamic test flow, it being understood that the embodiments described herein are for illustration and explanation of the invention only and are not intended to limit the invention thereto. It should be noted that, in the embodiment of the present invention, "continuous integration" refers to that a developer of continuous integration will periodically merge code changes into a central repository, after which the system will automatically run building and testing operations, and "test path" refers to an orderly test flow generated based on multiple test cases.

And constructing a mapping relation between the test case of the software and the functional module, associating the mapping relation with the modification of the code every day on the basis of the mapping relation, generating a test path for constructing the test every day, and then carrying out dynamic scheduling allocation of the test resources according to the generated test path and the existing test resources so as to carry out continuous daily integrated test.

The following illustrates the mapping relationship between the test cases and the product modules, and examples are shown in table 1:

TABLE 1

The mapping relation in the embodiment of the invention can be established after the product module and the test case are initially developed, and dynamic maintenance is required in the process of product iteration to ensure the integrity and the accuracy of the product module and the test case.

The foregoing is merely illustrative of the mapping relationship, and it should be understood that the embodiments described herein are merely illustrative and explanatory of the invention, and are not intended to limit the invention.

According to the scheme, the mapping relation between the test cases of the software and the functional modules is constructed; acquiring a target functional module, and generating a test path based on the target functional module and the mapping relation; the test is performed based on the test path matching test resources, so that dynamic software integration test is realized, the pertinence and the coverage rate of the test are improved, and the quality problem can be effectively solved earlier and more efficiently.

Specifically, the target functional module, namely, the functional module with modification of the software, acquires a set of test cases related to the functional module with modification based on the functional module with modification of the software and the mapping relation, and the set is the basis of test path generation. Taking FW software of an SSD solid state disk as an example, test cases to which a corresponding nvme protocol module may be associated include: readwrite, TRIM, etc. The test case assembly will be specifically described based on table 2.

TABLE 2

The foregoing is merely illustrative of a set of test cases, and it is to be understood that the embodiments described herein are merely illustrative and explanatory of the invention and are not restrictive of the invention.

Specifically, after determining the associated test case set, the priority of each test case in the test case set can be determined by comprehensively considering the test case attribute in the process of generating the test path, wherein the test case attribute comprises the case level, the execution time length and the like, and a specific priority determination strategy is as follows:

1) Providing multiple dimension determination use case priorities

Determining a priority based on the use case level: for example, P0 is a basic use case, P1 is an extended use case, P2 is an abnormal scene use case, and the execution sequence of P0-P2 use cases can be selected as follows: P0-P1-P2 or P2-P1-P0 may be executed by selecting only a partial level, for example, only a P0 level use case.

The priority is determined based on the time length of the use case, and the method can be performed selectively according to the time from long to short, or according to the time length from short to long, or only the use case in a partial time range, for example, only the use case in 24 hours.

A default execution order may be employed for all unselected use case dimensions: for example, if the use case level is not selected, execution may be prioritized from P0 by default.

2) Priority can be adjusted between dimensions:

after determining the priority in each dimension, we can select the execution priority among each dimension, for example, after confirming the priority according to the use case level, the use case of the same level confirms the priority according to the execution time, finally confirms the priority according to other dimensions, and the different dimensions can be flexibly adjusted.

According to the above priority determining policy, a list-form use case execution priority may be generated, as shown in table 3:

TABLE 3 Table 3

Use case priority	Case numbering	Attribution use case set	Use case level	Predicted time length
					1	readwrite01	readwrite use case	P0	0.5H-1H
2	readwrite02	readwrite use case	P0	1H-1.5H
					3	trim01	TRIM use case set	P0	0.5H-1H
4	trim02	TRIM use case set	P0	0.5H-1H
					5	trim03	TRIM use case set	P0	1H-1.5H
6	readwrite03	readwrite use case	P1	0.5H-1H
					7	readwrite04	readwrite use case	P1	1.5H-2H
8	readwrite05	readwrite use case	P1	2H-3H
					9	trim04	TRIM use case set	P1	0-0.5H
10	trim05	TRIM use case set	P1	2H-3H

The priority can be adjusted before application, and test cases are sequentially scheduled according to the priority during testing after the priority is confirmed to be a final version.

The above table is merely illustrative of the priorities of the various cases in the test case set, and it should be understood that the embodiments described herein are merely illustrative and explanatory of the invention and are not intended to limit the invention.

After determining the test priority of the use cases, we can combine the following test requirement dimensions of the use cases, supplement the requirements of each use case on the test resources, and the dimensions possibly involved are: test disk capacity (2 t,4t, etc.), test server type (server model M5, M6, etc.), tester operating system requirements, etc.

Test resource requirements may include special requirements in addition to generic test requirements. Special requirements generally refer to code modifications that explicitly affect only specific test environments or scenarios, e.g., code modifications affect only server models of specific CPU models. And so on. For test cases without special requirements, we will schedule in turn into the test resources (including machines and other including hard disk CPU resources) we can use. More test cases are related to special requirements, and the requirements can be added into the universal test resource dimension requirements in the test process.

In summary, the steps of generating a test path are as follows:

s11, acquiring a modified product module;

s12, based on the product module, finding out a corresponding test case in the mapping relation;

s13, forming a case set based on the found test cases;

s14, configuring the universal test resource requirement and the special test resource requirement of the test case;

after the above process is completed, a complete test path constructed at this time is generated, and the specific form of the test path may be as shown in table 4:

TABLE 4 Table 4

The above table is merely illustrative of test paths, and it should be understood that the embodiments described herein are merely illustrative and explanatory of the invention and are not intended to limit the invention.

According to the scheme, the dynamic integrated test for software code modification is realized, the pertinence and the coverage rate of the test are improved, and the quality problem can be effectively solved earlier and more efficiently.

Specifically, during the execution of the software test, the existing idle test resources are matched according to the test resource requirements and the use case priorities in the test path, until all the test resources are distributed, the next idle test resources need to be waited for distribution again, and after the matching of the idle test resources is finished, the test is started.

In the idle resource matching process, the load balancing principle can be followed, namely, on the premise of meeting the test requirement, all the test resources are ensured to be utilized uniformly as much as possible, rather than obvious difference of the busy and idle degrees of the test resources, the test ending time is nearly uniform as much as possible, and the whole test time is not prolonged due to the obvious difference of the test time of a certain machine.

At this time, if idle test resources appear, but the resource requirement of the next test case to be scheduled is not matched with the idle test resources, the idle test resources need to be forwarded to the use case with the highest priority of the available test resources.

Specifically, the mapping relation needs to be dynamically maintained in the software iteration process so as to ensure the integrity and the accuracy of the mapping relation. If a new functional module is added in the iterative process of the software, the mapping relation of the new module needs to be maintained, specifically, the mapping relation can be maintained by the following steps:

s21, analyzing whether the new function module can be tested by using a useful case in the original test cases;

s22, if the original test case can cover the test requirement of the functional module, the original test case is related to the functional module;

s23, if the original use case cannot cover or cannot cover the test requirement of the functional module by 100%, the association mapping between the new use case and the module is needed, and if part of the original use case is needed, the association mapping between the new use case and the functional module is also needed.

As the bug is discovered continuously during the product test, the accuracy of the mapping can be verified and supplemented accordingly.

Specifically, after the test is completed, the test data can be recorded and multidimensional analysis can be used as reference for the subsequent test. The test data may be a test duration that each test case executes under the current test resources. The following is illustrative:

in the testing process, according to the historical testing data, the expected ending time of the current use case of the current testing resource execution is predicted, and the time is possibly related to environmental factors greatly, so that a certain error exists, various dimensions are comprehensively considered according to the actual time after each test is ended, the time of the use case in different scenes is perfected and corrected, and more accurate expected time is provided for the next use case execution scheduling.

The historical test data mainly has reference significance for the test time of the use case in the test path generation process, and the more the historical test data, the more accurate the test time data of the same use case in different dimensions, and the more accurate the application in the test scheduling process.

In summary, with the increase of the continuous integration times, the dynamic test flow improves its accuracy and completeness, and its dynamic performance not only refers to each test, but also refers to the dynamic perfection and improvement in the iteration process of the whole software product.

Based on the same inventive concept, according to another aspect of the present invention, as shown in fig. 2, an embodiment of the present invention further provides a software testing system, including:

a building module 110, wherein the building module 110 is configured to build a mapping relation between test cases and functional modules of software;

a generating module 120, where the generating module 120 is configured to obtain a target functional module, and generate a test path based on the target functional module and the mapping relationship;

a test module 130, the test module 130 configured to perform a test based on the test path matching a test resource.

According to another aspect of the present invention, as shown in fig. 3, according to the same inventive concept, an embodiment of the present invention further provides a computer device 30, in which the computer device 30 includes a processor 310 and a memory 320, the memory 320 storing a computer program 321 executable on the processor, and the processor 310 executing the steps of the method as above.

The memory is used as a non-volatile computer readable storage medium, and can be used for storing non-volatile software programs, non-volatile computer executable programs and modules, such as program instructions/modules corresponding to the software testing method in the embodiment of the application. The processor executes various functional applications of the system and data processing by running non-volatile software programs, instructions and modules stored in the memory, i.e. implements the software testing method of the method embodiments described above.

The memory may include a memory program area and a memory data area, wherein the memory program area may store an operating system, at least one application program required for a function; the storage data area may store data created according to the use of the system, etc. In addition, the memory may include high-speed random access memory, and may also include non-volatile memory, such as at least one magnetic disk storage device, flash memory device, or other non-volatile solid-state storage device. In some embodiments, the memory optionally includes memory remotely located relative to the processor, the remote memory being connectable to the local module through a network. Examples of such networks include, but are not limited to, the internet, intranets, local area networks, mobile communication networks, and combinations thereof.

According to another aspect of the present invention, as shown in fig. 4, based on the same inventive concept, an embodiment of the present invention further provides a computer-readable storage medium 40, the computer-readable storage medium 40 storing a computer program 410 which when executed by a processor performs the above method.

Finally, it should be noted that, as will be appreciated by those skilled in the art, all or part of the procedures in implementing the methods of the embodiments described above may be implemented by a computer program for instructing relevant hardware, and the program may be stored in a computer readable storage medium, and the program may include the procedures of the embodiments of the methods described above when executed. The storage medium of the program may be a magnetic disk, an optical disk, a read-only memory (ROM), a random-access memory (RAM), or the like. The computer program embodiments described above may achieve the same or similar effects as any of the method embodiments described above.

Those of skill would further appreciate that the various illustrative logical blocks, modules, circuits, and algorithm steps described in connection with the disclosure herein may be implemented as electronic hardware, computer software, or combinations of both. To clearly illustrate this interchangeability of hardware and software, various illustrative components, blocks, modules, circuits, and steps have been described above generally in terms of their functionality. Whether such functionality is implemented as software or hardware depends upon the particular application and design constraints imposed on the overall system. Skilled artisans may implement the described functionality in varying ways for each particular application, but such implementation decisions should not be interpreted as causing a departure from the scope of the present disclosure.

The foregoing is an exemplary embodiment of the present disclosure, but it should be noted that various changes and modifications could be made herein without departing from the scope of the disclosure as defined by the appended claims. The functions, steps and/or actions of the method claims in accordance with the disclosed embodiments described herein need not be performed in any particular order. The foregoing embodiment of the present invention has been disclosed with reference to the number of embodiments for the purpose of description only, and does not represent the advantages or disadvantages of the embodiments. Furthermore, although elements of the disclosed embodiments may be described or claimed in the singular, the plural is contemplated unless limitation to the singular is explicitly stated.

It should be understood that as used herein, the singular forms "a", "an", and "the" are intended to include the plural forms as well, unless the context clearly supports the exception. It should also be understood that "and/or" as used herein is meant to include any and all possible combinations of one or more of the associated listed items.

Those of ordinary skill in the art will appreciate that: the above discussion of any embodiment is merely exemplary and is not intended to imply that the scope of the disclosure of embodiments of the invention, including the claims, is limited to such examples; combinations of features of the above embodiments or in different embodiments are also possible within the idea of an embodiment of the invention, and many other variations of the different aspects of the embodiments of the invention as described above exist, which are not provided in detail for the sake of brevity. Therefore, any omission, modification, equivalent replacement, improvement, etc. of the embodiments should be included in the protection scope of the embodiments of the present invention.

Claims

1. A method of testing software, comprising:

and testing based on the test path matching test resources.

2. The method of claim 1, wherein generating a test path based on the target functional module and the mapping relationship comprises:

3. The method of claim 2, wherein configuring the priority of each test case in the set of test cases comprises:

4. The method of claim 2, wherein testing based on the test path matching test resources comprises:

5. The method of claim 1, wherein the target functional module is a modified functional module in a software iteration process;

6. The method of claim 5, wherein dynamically maintaining the mapping relationship during the software iteration comprises:

7. The method of claim 4, wherein testing based on the test path matching test resources comprises:

8. A software testing system, comprising:

9. A computer device, comprising:

at least one processor; and

a memory storing a computer program executable on the processor, wherein the processor performs the steps of the method of any one of claims 1 to 7 when the program is executed.

10. A computer readable storage medium storing a computer program, characterized in that the computer program when executed by a processor performs the steps of the method according to any one of claims 1 to 7.