CN118035072A - Automatic acceptance method and system based on multi-version upgrading - Google Patents
Automatic acceptance method and system based on multi-version upgrading Download PDFInfo
- Publication number
- CN118035072A CN118035072A CN202311703137.9A CN202311703137A CN118035072A CN 118035072 A CN118035072 A CN 118035072A CN 202311703137 A CN202311703137 A CN 202311703137A CN 118035072 A CN118035072 A CN 118035072A
- Authority
- CN
- China
- Prior art keywords
- case
- test
- library
- automatic acceptance
- automatic
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
- 238000000034 method Methods 0.000 title claims abstract description 45
- 238000012360 testing method Methods 0.000 claims abstract description 67
- 230000006870 function Effects 0.000 claims abstract description 30
- 238000012545 processing Methods 0.000 claims abstract description 16
- 238000012795 verification Methods 0.000 claims abstract description 9
- 238000004590 computer program Methods 0.000 claims description 20
- 230000015654 memory Effects 0.000 claims description 17
- 238000003672 processing method Methods 0.000 claims description 7
- 238000012423 maintenance Methods 0.000 claims description 4
- 230000001360 synchronised effect Effects 0.000 claims description 2
- 238000011161 development Methods 0.000 abstract 1
- 238000010586 diagram Methods 0.000 description 6
- 230000003287 optical effect Effects 0.000 description 3
- 238000013500 data storage Methods 0.000 description 2
- 238000012216 screening Methods 0.000 description 2
- 239000004065 semiconductor Substances 0.000 description 2
- 230000009286 beneficial effect Effects 0.000 description 1
- 238000012790 confirmation Methods 0.000 description 1
- 238000004519 manufacturing process Methods 0.000 description 1
- 239000007787 solid Substances 0.000 description 1
Classifications
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
- Y02P—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN THE PRODUCTION OR PROCESSING OF GOODS
- Y02P90/00—Enabling technologies with a potential contribution to greenhouse gas [GHG] emissions mitigation
- Y02P90/30—Computing systems specially adapted for manufacturing
Landscapes
- Debugging And Monitoring (AREA)
Abstract
The invention discloses an automatic acceptance method and system based on multi-version upgrade, which relate to the field of IT and software development and comprise the following steps: designing a test case baseline for all functions of the product, and gradually describing verification function points, service scenes and expected results by utilizing a test platform structure and a formatting language; for the existing test case base line, synchronously matching a code case base; performing range marking processing by using a test case base line according to the functional range to be verified, and converting the selected case into an execution case of the code case library; and (3) saving the use case result of the automatic acceptance test, comparing with the expected result of the use case baseline, returning the automatic acceptance result, and automatically saving the failed service scene and the error reporting reason to a fault library. The invention can skip the process of manually creating the automatic task, reduce the use burden of operators, accelerate the fault processing flow before product online, and avoid repeated problems to find the locating obstacle-removing of the development team.
Description
Technical Field
The invention belongs to the field of IT and software development, and particularly relates to an automatic acceptance method and system based on multi-version upgrading.
Background
When the resource pool is on line, a tester is required to perform function acceptance. The method is usually carried out manually as a tester in the first stage of the verification work according to a test library created by developing tests. The second stage is implemented by the tester by fixing a certain range of use and adding it to the automation task, and recording the accumulated fault library and the treatment method. And a third stage, delivering the work to other personnel for execution, and processing corresponding problems according to the fault library. If the automatic task is successfully executed, the product can be online through verification.
After the third stage, the version to be released in the resource pool has new function points, and further other function configurations need to be gradually added in the later stage, so that the current working mode cannot meet the requirements. The method is that the testing personnel and the operation and maintenance personnel are required to communicate the confirmation function range, and then the testing personnel execute the checking work after screening the automatic execution use cases.
Moreover, at present, the operator may not be familiar with the code case library, and the operator cannot continue to perform the operation for other people.
In view of this, the invention provides an automatic acceptance method and system based on multi-version upgrade, which is used for executing automatic acceptance projects and reducing the use burden of the work without manually screening code use case libraries when upgrading/online under the condition of large version difference of a resource pool.
Disclosure of Invention
The present invention is directed to an automatic acceptance method based on multi-version upgrade, so as to solve the above-mentioned problems in the background art.
In order to achieve the above purpose, the present invention provides the following technical solutions: an automatic acceptance method based on multi-version upgrading comprises the following specific steps:
S1, designing a test case baseline for all functions of a product, and gradually describing verification function points, service scenes and expected results by utilizing a test platform structure and a formatting language;
s2, synchronously matching the code case library with the existing test case base line;
s3, performing range marking processing by using a test case base line according to the functional range to be verified, and converting the selected case into an execution case of the code case library;
S4, saving the case result of the automatic acceptance test, comparing with the expected result of the case base line, returning the automatic acceptance result, and automatically saving the failed business scene and the error reporting reason to a fault library.
The invention is further improved in that the test platform structure represents a tree structure of a class mind map, wherein the functional points to be verified and the service scene are used as child nodes of a root node, and the expected result is used as a leaf node;
the invention is further improved in that the formatting language includes describing test actions in a GWT format using keywords within the structured natural language as a start;
The invention is further improved in that the code case library refers to an automatic code item maintained by a tester for a long time; the synchronous matching process comprises the steps of adding notes @ or labels-labels, and adding function points and business scenes into an automation project.
The invention further improves that the range marking processing is carried out on the test case base line, namely, an operation and maintenance person confirms the function background required by the resource pool updated at the time, and the label is added by the function points required to be verified at the time in the test case base line on the test platform.
The invention further improves that the use cases are converted into the execution use cases of the code use case library, namely the test platform processes the content into a plurality of records according to the marked functional points to be tested and the content of the service scene, and the records are matched with the annotation and the label language of the code use case library, so that the test use case codes in the target range can be automatically executed.
The invention is further improved in that the execution result of the automatic acceptance test is saved and comprises a text type and a picture type, the use case platform compares the obtained actual execution result with a preset expected result in similarity, and the automatic acceptance is returned to be successful when all use cases are successfully executed; if the use case fails to execute, returning a service scene and reasons of automatic acceptance failure and failure; for a failed service scene, a fault library is queried, a history processing method is checked, and the problem root is solved; if the inquiry fails, the history does not have the same problem scene and cause, the problem scene and cause are automatically added into a fault library, the problem is processed by a developer, and the processing method is registered into the fault library in detail.
In another aspect, the present invention provides a multi-version upgrade-based automated acceptance system comprising:
The case baseline full coverage module is used for designing a test case baseline for all functions of the product, and gradually describing verification function points, service scenes and expected results by utilizing a test platform structure and a formatting language;
and the code case library synchronization module is used for synchronously matching the code case library with the existing test case base line.
The automatic deduction execution module is used for carrying out range marking processing by using a test case base line according to the functional range to be verified and converting the selected case into an execution case of the code case library;
The automatic result acceptance module is used for saving the use case result of the automatic acceptance test, comparing the use case result with the expected result of the use case baseline and returning the automatic acceptance result; and automatically storing the failed service scene and the error reporting reason into a fault library.
An electronic device, comprising: a processor and a memory, wherein the memory stores a computer program for the processor to call;
the processor executes any one of the automatic acceptance methods and systems based on multi-version upgrade by calling the computer program stored in the memory.
A computer readable storage medium storing instructions that when executed on a computer cause the computer to perform any of the above-described multi-version upgrade-based automated acceptance methods and systems.
Compared with the prior art, the invention has the beneficial effects that:
1. The burden of the work can be reduced, and the automation project can be executed by any person, and the functional range only needs to be marked on the base line of the test case platform.
2. The standard formatting of the test case can be performed, the readability of the test case base line is improved, and the service scene corresponding to the pointed out case is clearly displayed.
3. The problem of acceptance results can be rapidly processed, and for business scenes with failure acceptance, the problem is rapidly eliminated from the root according to the processing method in the accumulated fault library.
Drawings
FIG. 1 is a flow chart of a method for automated acceptance based on multi-version upgrades of the present invention;
Detailed Description
The following description of the embodiments of the present invention will be made clearly and completely with reference to the accompanying drawings, in which it is apparent that the embodiments described are only some embodiments of the present invention, but not all embodiments.
Example 1
The embodiment shows an automatic acceptance method based on multi-version upgrading, which comprises the following specific steps:
S1, designing a test case baseline for all functions of a product, and gradually describing verification function points, service scenes and expected results by utilizing a test platform structure and a formatting language;
In this embodiment, the test platform structure refers to a tree structure of a thought-like guide. The functional point to be verified and the service scene are used as child nodes of the root node, and the expected result is used as a leaf node. The formatting language used refers to describing test actions in a GWT format, using keywords in a structured natural language as a start, briefly, for example: the pre-condition is as follows: user opening object storage service
S2, synchronously matching the code case library with the existing test case base line;
In this embodiment, the code case library refers to an automated code item maintained by a tester for a long period of time. To complete the matching synchronization with the use case base line. An annotation @ or label-label needs to be added to add the function point and the business scenario to the automation project. The language used by the code instance library is Java.
S3, performing range marking processing by using a test case base line according to the functional range to be verified, and converting the selected case into an execution case of the code case library;
In this embodiment, the range marking process is performed on the test case baseline, which means that the operation and maintenance personnel determine the functional background required by the resource pool updated this time, and add the label by verifying the functional point required this time in the test case baseline on the test platform. The selected use case is converted into the execution use case of the code use case library, namely, according to the marked functional points to be tested and the content of the service scene, the test platform processes the content into a plurality of records, and the records are matched with the annotation and the label language of the code use case library, so that the test use case codes in the target range are automatically executed
S4, saving the case result of the automatic acceptance test, comparing with the expected result of the case base line, returning the automatic acceptance result, and automatically saving the failed business scene and the error reporting reason to a fault library.
In this embodiment, the execution result of the automatic acceptance test is saved, and may be a text type or a picture type. And then the use case platform compares the obtained actual execution result with a preset expected result in similarity, such as a returned request barrel list body, and compares whether the number of Key keywords and the content in the request barrel list body are equal. For all use cases, the execution is successful, and the automatic acceptance is returned to be successful; if the use case fails to execute, the automatic acceptance failure and the service scene and reason of the failure are returned. For a failed service scene, a fault library is queried, a history processing method is checked, and the problem root is solved; if the inquiry fails, the history does not have the same problem scene and cause, the problem scene and cause are automatically added into a fault library, the problem is processed by a developer, and the processing method is registered into the fault library in detail.
Example 2
A multi-version upgrade based automated acceptance system based on a multi-version upgrade based automated acceptance method of any of the claims, comprising:
The case baseline full coverage module is used for designing a test case baseline for all functions of the product, and gradually describing verification function points, service scenes and expected results by utilizing a test platform structure and a formatting language;
and the code case library synchronization module is used for synchronously matching the code case library with the existing test case base line.
The automatic deduction execution module is used for carrying out range marking processing by using a test case base line according to the functional range to be verified and converting the selected case into an execution case of the code case library;
The automatic result acceptance module is used for saving the use case result of the automatic acceptance test, comparing the use case result with the expected result of the use case baseline and returning the automatic acceptance result; and automatically storing the failed service scene and the error reporting reason into a fault library.
Example 3
The present embodiment provides an electronic device including: a processor and a memory, wherein the memory stores a computer program for the processor to call;
The processor executes the method and system for automatic acceptance based on multi-version upgrade by calling the computer program stored in the memory.
The electronic device may vary greatly in configuration or performance, and can include one or more processors (Central Processing Units, CPU) and one or more memories, where the memories store at least one computer program that is loaded and executed by the processors to implement the method and system for multi-version upgrade-based automated acceptance provided by the above method embodiments. The electronic device can also include other components for implementing the functions of the device, for example, the electronic device can also have wired or wireless network interfaces, input-output interfaces, and the like, for inputting and outputting data. The present embodiment is not described herein.
Example 4
The present embodiment proposes a computer-readable storage medium 200 on which is stored an erasable computer program;
the computer program, when run on the computer device, causes the computer device to perform the method and system for automatic acceptance based on multi-version upgrade.
For example, the computer readable storage medium 200 can be Read-Only Memory (ROM), random access Memory (RandomAccess Memory, RAM), compact disk Read-Only Memory (Compact Disc Read-Only Memory, CD-ROM), magnetic tape, floppy disk, optical data storage device, etc.
It should be understood that, in various embodiments of the present application, the sequence numbers of the foregoing processes do not mean the order of execution, and the order of execution of the processes should be determined by the functions and internal logic thereof, and should not constitute any limitation on the implementation process of the embodiments of the present application.
It should be understood that determining B from a does not mean determining B from a alone, but can also determine B from a and/or other information.
The above embodiments may be implemented in whole or in part by software, hardware, firmware, or any other combination. When implemented in software, the above-described embodiments may be implemented in whole or in part in the form of a computer program product. The computer program product comprises one or more computer instructions or computer programs. When the computer instructions or computer program are loaded or executed on a computer, the processes or functions in accordance with embodiments of the present invention are produced in whole or in part. The computer may be a general purpose computer, a special purpose computer, a computer network, or other programmable apparatus. The computer instructions may be stored in or transmitted from one computer-readable storage medium to another, for example, by way of wired or/and wireless networks from one website site, computer, server, or data center to another. Computer readable storage media can be any available media that can be accessed by a computer or data storage devices, such as servers, data centers, etc. that contain one or more collections of available media. The usable medium may be a magnetic medium (e.g., floppy disk, hard disk, magnetic tape), an optical medium (e.g., DVD), or a semiconductor medium. The semiconductor medium may be a solid state disk.
It will be appreciated by those skilled in the art that embodiments of the present invention may be provided as a method, system, or computer program product. Accordingly, the present invention may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects. Furthermore, the present invention may take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, and the like) having computer-usable program code embodied therein.
The present invention is described with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems) and computer program products according to embodiments of the invention. It will be understood that each flow and/or block of the flowchart illustrations and/or block diagrams, and combinations of flows and/or blocks in the flowchart illustrations and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer program instructions may also be stored in a computer-readable memory that can direct a computer or other programmable data processing apparatus to function in a particular manner, such that the instructions stored in the computer-readable memory produce an article of manufacture including instruction means which implement the function specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer program instructions may also be loaded onto a computer or other programmable data processing apparatus to cause a series of operational steps to be performed on the computer or other programmable apparatus to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide steps for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
The embodiments of the present invention have been described above with reference to the accompanying drawings, but the present invention is not limited to the above-described embodiments, which are merely illustrative and not restrictive, and many forms may be made by those having ordinary skill in the art without departing from the spirit of the present invention and the scope of the claims, which are all within the protection of the present invention.
Claims (10)
1. An automatic acceptance method based on multi-version upgrading is characterized in that: the method comprises the following specific steps:
S1, designing a test case baseline for all functions of a product, and gradually describing verification function points, service scenes and expected results by utilizing a test platform structure and a formatting language;
s2, synchronously matching the code case library with the existing test case base line;
s3, performing range marking processing by using a test case base line according to the functional range to be verified, and converting the selected case into an execution case of the code case library;
S4, saving the case result of the automatic acceptance test, comparing with the expected result of the case base line, returning the automatic acceptance result, and automatically saving the failed business scene and the error reporting reason to a fault library.
2. The multi-version upgrade-based automatic acceptance method of claim 1, wherein: the test platform structure represents a tree structure of a class mind map, wherein functional points to be verified and service scenes are used as child nodes of a root node, and expected results are used as leaf nodes.
3. The multi-version upgrade-based automatic acceptance method of claim 2, wherein: the formatting language includes describing test actions in a GWT format using keywords within a structured natural language as a start.
4. A multi-version upgrade-based automated acceptance method of claim 3, wherein: the code case library refers to an automatic code item maintained by a tester for a long time; the synchronous matching process comprises the steps of adding notes @ or labels-labels, and adding function points and business scenes into an automation project.
5. The multi-version upgrade-based automatic acceptance method of claim 4, wherein: and the range marking processing is carried out on the test case base line, namely, an operation and maintenance person definitely confirms the functional background required by the resource pool updated at the time, and the labels are added by the functional points which need to be verified at the time in the test case base line on the test platform.
6. The multi-version upgrade-based automatic acceptance method of claim 5, wherein: the use case is converted into an execution use case of the code use case library, namely the test platform processes the content into a plurality of records according to the marked functional points to be tested and the content of the service scene, and the records are matched with the annotation and the label language of the code use case library, so that the test use case codes in the target range are automatically executed.
7. The multi-version upgrade-based automatic acceptance method of claim 6, wherein: the method comprises the steps that the execution results of the automatic acceptance test are stored, wherein the execution results comprise text types and picture types, the use case platform compares the obtained actual execution results with preset expected results in similarity, and the automatic acceptance test is returned to be successful when all use cases are successfully executed; if the use case fails to execute, returning a service scene and reasons of automatic acceptance failure and failure; for a failed service scene, a fault library is queried, a history processing method is checked, and the problem root is solved; if the inquiry fails, the history does not have the same problem scene and cause, the problem scene and cause are automatically added into a fault library, the problem is processed by a developer, and the processing method is registered into the fault library in detail.
8. A multi-version upgrade based automatic acceptance system implemented based on a multi-version upgrade based automatic acceptance method of any of claims 1-7, comprising:
The case baseline full coverage module is used for designing a test case baseline for all functions of the product, and gradually describing verification function points, service scenes and expected results by utilizing a test platform structure and a formatting language;
and the code case library synchronization module is used for synchronously matching the code case library with the existing test case base line.
The automatic deduction execution module is used for carrying out range marking processing by using a test case base line according to the functional range to be verified and converting the selected case into an execution case of the code case library;
The automatic result acceptance module is used for saving the use case result of the automatic acceptance test, comparing the use case result with the expected result of the use case baseline and returning the automatic acceptance result; and automatically storing the failed service scene and the error reporting reason into a fault library.
9. An electronic device, comprising: a processor and a memory, wherein the memory stores a computer program for the processor to call;
the processor performs a multi-version upgrade-based auto-acceptance method of any of claims 1-7 by invoking a computer program stored in the memory.
10. A computer-readable storage medium, characterized by: instructions stored thereon which, when executed on a computer, cause the computer to perform a multi-version upgrade-based auto-acceptance method as claimed in any of claims 1 to 7.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202311703137.9A CN118035072A (en) | 2023-12-12 | 2023-12-12 | Automatic acceptance method and system based on multi-version upgrading |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202311703137.9A CN118035072A (en) | 2023-12-12 | 2023-12-12 | Automatic acceptance method and system based on multi-version upgrading |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN118035072A true CN118035072A (en) | 2024-05-14 |
Family
ID=90997622
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202311703137.9A Pending CN118035072A (en) | 2023-12-12 | 2023-12-12 | Automatic acceptance method and system based on multi-version upgrading |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN118035072A (en) |
-
2023
- 2023-12-12 CN CN202311703137.9A patent/CN118035072A/en active Pending
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN110309071B (en) | Test code generation method and module, and test method and system | |
| CN111240994B (en) | Vulnerability processing method and device, electronic equipment and readable storage medium | |
| US6182245B1 (en) | Software test case client/server system and method | |
| US8914679B2 (en) | Software testing automation framework | |
| Mariani et al. | Dynamic detection of cots component incompatibility | |
| CN110941528B (en) | Log buried point setting method, device and system based on fault | |
| CN113448862B (en) | Software version testing method and device and computer equipment | |
| CN111694612A (en) | Configuration checking method, device, computer system and storage medium | |
| JP2015011372A (en) | Debug support system, method, program, and recording medium | |
| CN110990289B (en) | Method and device for automatically submitting bug, electronic equipment and storage medium | |
| US8595559B2 (en) | Method and apparatus for model-based testing of a graphical user interface | |
| CN115658452A (en) | Buried point checking method, buried point checking device, readable storage medium and electronic equipment | |
| CN114661423A (en) | Cluster configuration detection method and device, computer equipment and storage medium | |
| CN110865806A (en) | Code processing method, device, server and storage medium | |
| CN116599881A (en) | Cloud platform tenant modeling test method, device, equipment and storage medium | |
| CN111752838A (en) | Question checking method and device, server and storage medium | |
| CN118035072A (en) | Automatic acceptance method and system based on multi-version upgrading | |
| CN115617668A (en) | Compatibility testing method, device and equipment | |
| CN115705297A (en) | Code call detection method, device, computer equipment and storage medium | |
| CN113568834A (en) | SDK code compatibility detection method, device, computer equipment and medium | |
| CN111767222A (en) | Data model verification method and device, electronic equipment and storage medium | |
| CN113360365A (en) | Flow testing method and flow testing system | |
| US20230195609A1 (en) | Automatic generation of summary report for validation tests of computing systems | |
| CN117573564B (en) | Method for automatically identifying differences based on gitlab code submitted log | |
| CN111897568B (en) | System verification method, device, equipment and storage medium |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination |