WO2022135276A1

WO2022135276A1 - Method and apparatus for processing test cases, and storage medium

Info

Publication number: WO2022135276A1
Application number: PCT/CN2021/138935
Authority: WO
Inventors: 骆春光; 王惠惠; 曾庆熙; 曾波
Original assignee: 深圳前海微众银行股份有限公司
Priority date: 2020-12-22
Filing date: 2021-12-16
Publication date: 2022-06-30
Also published as: CN112783760B; CN112783760A

Abstract

Provided in the present application are a method and apparatus for processing test cases, and a storage medium. The method comprises: obtaining a test case to be saved and the latest test case saved in a database; determining at least one piece of difference data between the test case to be saved and the latest test case, and a difference type corresponding to the difference data; sending a first message to a first terminal device, the first message comprising the difference data and the difference type, and the first message being used for instructing the first terminal device to display the difference data and the difference type; receiving a second message sent by the first terminal device, the second message comprising target difference data and a target difference type corresponding to the target difference data, the target difference data being data in the at least one piece of difference data; and generating a target test case according to the target difference data, the target difference type, and the latest test case. The present application can improve the accuracy of target test cases.

Description

Test case processing method, device and storage medium

This application is based on the Chinese patent application with the application number of 202011530719.8, the application date is December 22, 2020, and the application name is "Test Case Processing Method, Device and Storage Medium", and claims the priority of the Chinese patent application, the The entire contents of the Chinese patent application are incorporated herein by reference.

technical field

The present application relates to computer technology, and in particular, to a test case processing method, device and storage medium.

Background technique

With the development of computer technology, more and more technologies (big data, distributed, artificial intelligence, etc.) are applied in the financial field, and the traditional financial industry is gradually transforming into financial technology (Fintech). Real-time requirements also put forward higher requirements for service request technology. At present, in the field of financial technology, in order to ensure the accuracy of the program or application, it is usually necessary to use test cases to automatically test the program or application.

In the prior art, since the functions of programs or applications are constantly changing, in order to ensure the accuracy of the test, it is necessary to edit or modify the test case. The test case will overwrite the previously saved test case, so that the user cannot view the modifications made to the test case in the previously saved version, and the later saved test case directly overwrites the previously saved test case, which will affect the accuracy of the final saved test case.

SUMMARY OF THE INVENTION

In order to solve the problems existing in the prior art, the present invention provides a test case processing method, device and storage medium, which can not only enable the user to view the modifications made to the test case in the previously saved version, but also improve the final saved test. Use case accuracy.

In a first aspect, an embodiment of the present application provides a method for processing a test case, which is applied to a server, and the method includes:

If it is detected that the basic test case is in an unlocked state, the test case to be saved and the latest test case that has been saved in the database are obtained, and the test case to be saved and the latest test case are to modify the basic test case respectively. obtained after

determining at least one difference data between the to-be-saved test case and the latest test case, and a difference type corresponding to the difference data, where the difference type includes at least one of an addition type, a deletion type, and a modification type;

sending a first message to a first terminal device, where the first message includes the difference data and the difference type;

Receive a second message sent by the first terminal device, where the second message includes target difference data and a target difference type corresponding to the target difference data, and the target difference data is one of the at least one difference data. data;

A target test case is generated according to the target difference data, the target difference type and the latest test case.

Optionally, obtaining the test case to be saved and the latest test case saved in the database includes:

receiving a third message sent by the first terminal device, where the third message includes the test case to be saved and the version identifier of the test case to be saved;

obtaining the version identifier of the latest test case according to the third message;

If the version identifier of the test case to be saved is different from the version identifier of the latest test case, the latest test case is acquired from the database.

Optionally, the determining at least one difference data between the test case to be saved and the latest test case, and the difference type corresponding to the difference data, include:

Compare the test case to be saved with the latest test case, and determine the longest common subsequence of the test case to be saved and the latest test case;

Comparing the test case to be saved and the latest test case with the longest common subsequence respectively, comparing the different data between the test case to be saved and the longest common subsequence, and the The difference data between the latest test case and the longest common subsequence is determined as the at least one difference data;

According to the at least one difference data and the longest common subsequence, a difference type corresponding to the difference data is determined.

Optionally, the target test case is generated according to the target difference data, the target difference type and the latest test case, including:

If it is determined that the target difference data corresponding to the target difference type is data in the latest test case, then the latest test case is determined to be the target test case; or,

If it is determined that the target difference data corresponding to the target difference type is the data in the test case to be saved, then in the latest test case, the target difference data corresponding to the target difference type is performed operations to generate the target test case; or,

If it is determined that the first data in the target difference data is the data in the latest test case, and the second data is the data in the to-be-saved test case, keep the first data in the latest test case A piece of data and a difference type corresponding to the first data remain unchanged, and in the latest test case, an operation corresponding to the difference type of the second data is performed on the second data to generate the target test case.

Optionally, the method further includes:

If it is detected that the basic test case corresponding to the first terminal device is in a locked state, a lock message is sent to a second terminal device other than the first terminal device, where the lock message includes the basic test case The lock message is used to instruct the second terminal device to set the basic test case corresponding to the second terminal device to a locked state.

Optionally, the method further includes:

When the preset condition is met, an unlock message is sent to the second terminal device, where the unlock message includes the version identifier of the basic test case in the locked state, the unlock message is used to instruct the generation of the first value and the The second terminal device unlocks the basic test case in the locked state when judging that the first value is the same as the pre-stored second value; the preset condition includes the basic test case in the locked state. The locking duration exceeds a preset duration, and/or a fifth message sent by the first terminal device is received, where the fifth message is used to indicate that the basic test case in the locked state is saved.

In a second aspect, an embodiment of the present application provides a method for processing a test case, which is applied to a terminal device, and the method includes:

Receive the first message sent by the server, the first message includes at least one difference data and the difference type corresponding to each difference data, the difference data is the difference data between the test case to be saved and the latest test case, the The test case to be saved and the latest test case are obtained by modifying the basic test case;

Determine target difference data and the target difference type corresponding to the target difference data, and the target difference data is the data in the at least one difference data;

Send the second message to the server, the second message includes the target difference data and the target difference type, and the second message is used to instruct the server according to the target difference data, the The target difference type and the latest test case are generated, and the target test case is generated.

Optionally, the determining the target difference data and the target difference type corresponding to the target difference data includes:

displaying the difference data and the difference type;

A first operation instruction triggered by a user is received, where the first operation instruction includes the target difference data and the target difference type.

Optionally, the method further includes:

receiving a second operation instruction triggered by the user, where the second operation instruction is used to save the to-be-saved test case;

According to the second operation instruction, a third message is sent to the server, where the third message includes the test case to be saved and the version identifier of the test case to be saved, and the third message is used to indicate the test case to be saved. The server acquires the version identifier of the latest test case, and when the version identifier of the test case to be saved is different from the version identifier of the latest test case, acquires the latest test case from the database.

Optionally, the method further includes:

receiving a third operation instruction triggered by the user, where the third operation instruction includes the version identifier of the basic test case to be locked;

According to the third operation instruction, a fourth message is sent to the server, where the fourth message includes the version identifier of the basic test case to be locked, and the fourth message is used to instruct the server to send a message to the terminal except the terminal A second terminal device other than the device sends a lock message, where the lock message includes the version identifier of the basic test case to be locked, and the lock message is used to indicate that the second terminal device will The basic test case to be locked corresponding to the device is set to a locked state.

Optionally, the method further includes:

receiving a fourth operation instruction triggered by the user, where the fourth operation instruction is used to instruct to save the basic test case in the locked state;

According to the fourth operation instruction, a fifth message is sent to the server, where the fifth message is used to instruct the server to send an unlocking message to the second terminal device, where the unlocking message includes the basic information in a locked state The version identifier of the test case, the unlock message is used to instruct the generation of the first value, and instruct the second terminal device to lock the device in the locked state when judging that the first value is the same as the pre-stored second value. Basic test cases are unlocked.

In a third aspect, an embodiment of the present application provides a processing device for a test case, including:

The processing module is used to obtain the test case to be saved and the latest test case saved in the database when it is detected that the basic test case is in an unlocked state, and the test case to be saved and the latest test case are for the basic test case respectively. After the use case is modified;

The processing module is further configured to determine at least one difference data between the test case to be saved and the latest test case, and a difference type corresponding to the difference data, where the difference type includes addition type, deletion type and modification at least one of the types;

a sending module, configured to send a first message to a first terminal device, where the first message includes the difference data and the difference type;

A receiving module, configured to receive a second message sent by the first terminal device, where the second message includes target difference data and a target difference type corresponding to the target difference data, and the target difference data is the at least data in a difference data;

The processing module is further configured to generate a target test case according to the target difference data, the target difference type and the latest test case.

Optionally, the processing module is specifically used for:

optional,

The sending module is further configured to send a lock message to a second terminal device other than the first terminal device when it is detected that the basic test case corresponding to the first terminal device is in a locked state, and the lock The message includes the version identifier of the basic test case, and the lock message is used to instruct the second terminal device to set the basic test case corresponding to the second terminal device to a locked state.

Optionally, the sending module is further configured to send an unlock message to the second terminal device when a preset condition is met, where the unlock message includes a version identifier of the basic test case in a locked state, and the unlock message The message is used to instruct the generation of the first value, and instruct the second terminal device to unlock the basic test case in the locked state when it determines that the first value is the same as the pre-stored second value; the preset The condition includes that the lock duration of the basic test case in the locked state exceeds a preset duration, and/or a fifth message sent by the first terminal device is received, and the fifth message is used to indicate that the locked The state of the underlying test case is saved.

In a fourth aspect, an embodiment of the present application provides a processing device for a test case, including:

The receiving module is configured to receive a first message sent by the server, where the first message includes at least one difference data and a difference type corresponding to each difference data, and the difference data is the difference between the test case to be saved and the latest test case. Difference data, the test case to be saved and the latest test case are obtained by modifying the basic test case;

a processing module for determining target difference data and a target difference type corresponding to the target difference data, the target difference data being the data in the at least one difference data;

a sending module, configured to send the second message to the server, where the second message includes the target difference data and the target difference type, and the second message is used to instruct the server according to the target difference The difference data, the target difference type and the latest test case are used to generate a target test case.

Optionally, the device further includes: a display module;

the display module, for displaying the difference data and the difference type;

The receiving module is further configured to receive a first operation instruction triggered by a user, where the first operation instruction includes the target difference data and the target difference type.

Optionally, the receiving module is further configured to receive a second operation instruction triggered by the user, where the second operation instruction is used to save the test case to be saved;

The sending module is further configured to send a third message to the server according to the second operation instruction, where the third message includes the test case to be saved and the version identifier of the test case to be saved, The third message is used to instruct the server to obtain the version identifier of the latest test case, and when the version identifier of the to-be-saved test case is different from the version identifier of the latest test case, obtain the version identifier of the latest test case from the database. Describe the latest test case.

Optionally, the receiving module is further configured to receive a third operation instruction triggered by the user, where the third operation instruction includes the version identifier of the basic test case to be locked;

The sending module is further configured to send a fourth message to the server according to the third operation instruction, where the fourth message includes the version identifier of the basic test case to be locked, and the fourth message is used to indicate The server sends a lock message to a second terminal device other than the terminal device, where the lock message includes the version identifier of the basic test case to be locked, and the lock message is used to indicate the second terminal The device will set the basic test case to be locked corresponding to the second terminal device to a locked state.

Optionally, the receiving module is further configured to receive a fourth operation instruction triggered by the user, where the fourth operation instruction is used to instruct to save the basic test case in a locked state;

The sending module is further configured to send a fifth message to the server according to the fourth operation instruction, where the fifth message is used to instruct the server to send an unlocking message to the second terminal device, and the unlocking The message includes the version identifier of the basic test case in the locked state, and the unlock message is used to instruct the generation of the first value, and instruct the second terminal device to determine that the first value is inconsistent with the pre-stored second value. At the same time, the basic test case in the locked state is unlocked.

In a fifth aspect, an embodiment of the present application provides a server, including: a transceiver; a processor; a memory; and a computer program;

Wherein the computer program is stored in the memory and configured to be executed by the processor, the computer program comprising instructions for performing the method of the first aspect.

In a sixth aspect, an embodiment of the present application provides a terminal device, including: a transceiver; a display; a processor; a memory; and a computer program;

Wherein the computer program is stored in the memory and configured to be executed by the processor, the computer program comprising instructions for performing the method of the second aspect.

In a seventh aspect, an embodiment of the present application provides a computer-readable storage medium, where the computer-readable storage medium stores a computer program, and the computer program causes the server to execute the method described in the first aspect or cause the terminal device to execute the method described in the first aspect. The method described in the second aspect.

In an eighth aspect, an embodiment of the present application provides a computer program product, including a computer program, which implements the method according to the first aspect or the second aspect when the computer program is executed by a processor.

In the test case processing method, device and storage medium provided by the embodiments of the present application, when it is detected that the basic test case is in an unlocked state, the test case to be saved and the latest test case saved in the database are obtained, and the test case to be saved is determined. at least one difference data between the test case and the latest test case, as well as the difference type corresponding to the difference data, and then send a first message to the first terminal device, the first message includes the difference data and the difference type, by receiving the first terminal device The second message sent includes the target difference data and the target difference type corresponding to the target difference data, and the target test case is generated according to the target difference data, the target difference type and the latest test case. When the server saves the test case to be saved, it determines at least one difference data between the test case to be saved and the latest test case, and generates the target test case according to the target difference data determined by the terminal device and the corresponding target difference type, thereby avoiding The phenomenon in the prior art that the test case saved before is directly used to cover the test case saved before is realized, and the difference data is selectively saved, so that the accuracy of the target test case can be improved.

Description of drawings

In order to explain the embodiments of the present invention or the technical solutions in the prior art more clearly, the following briefly introduces the accompanying drawings that need to be used in the description of the embodiments or the prior art. Obviously, the accompanying drawings in the following description are only These are some embodiments of the present invention, and for those of ordinary skill in the art, other drawings can also be obtained from these drawings without any creative effort.

1 is a system architecture diagram of a method for processing a test case provided by an embodiment of the present application;

2 is a signaling diagram of a method for processing a test case provided by an embodiment of the present application;

Fig. 3 is the trigger schematic diagram of the second operation instruction;

Fig. 4 is the display schematic diagram of difference data;

FIG. 5 is another signaling diagram of a method for processing a test case provided by an embodiment of the present application;

6 is a schematic diagram of triggering a third operation instruction;

FIG. 7 is another signaling diagram of a method for processing a test case provided by an embodiment of the present application;

FIG. 8 is a schematic diagram of a processing device for a test case provided by an embodiment of the present application;

FIG. 9 is a schematic diagram of a processing device for a test case provided by an embodiment of the present application;

FIG. 10 is a schematic structural diagram of a server embodiment provided by an embodiment of the present application;

FIG. 11 is a schematic structural diagram of an embodiment of a terminal device according to an embodiment of the application.

Detailed ways

The technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings in the embodiments of the present invention. Obviously, the described embodiments are only a part of the embodiments of the present invention, but not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those of ordinary skill in the art without creative efforts shall fall within the protection scope of the present invention.

The terms "first", "second", "third" and "fourth", etc. (if any) in the description and claims of the present invention and the above-mentioned drawings are used to distinguish similar objects and are not necessarily used to describe a specific order or sequence. It is to be understood that the data so used may be interchanged under appropriate circumstances such that the embodiments of the invention described herein can be practiced in sequences other than those illustrated or described herein. Furthermore, the terms "comprising" and "having" and any variations thereof, are intended to cover non-exclusive inclusion, for example, a process, method, system, product or device comprising a series of steps or units is not necessarily limited to those expressly listed Rather, those steps or units may include other steps or units not expressly listed or inherent to these processes, methods, products or devices.

In order to help those skilled in the art better understand the technical solutions of the present application, the relevant content involved in the technical solutions of the present application will be introduced below.

(1) Automated testing refers to automatically simulating the real operation of the execution interface according to the usage scenario of the system to test whether the function is correct.

(2) Test case (Test Case) refers to the description of the test task for a specific software product, reflecting the test plan, method, technology and strategy. Its content includes test target, test environment, input data, test steps, expected results and test scripts.

(3) Redis is a high-performance key-value data storage database based on memory.

The method for processing test cases provided by the embodiments of the present application can be applied to scenarios in which test cases are used to automate testing of programs or applications, or when multiple users edit or modify the same test case, how to use test cases such as in the context of effective management.

In the above scenario, multiple testers can be allowed to modify or edit the test case, that is, multiple people can edit the same test case at the same time. In the prior art, when multiple users edit the same test case, the test cases are usually saved according to the chronological sequence of editing, so that the test case saved later will overwrite the test case saved before. For example, if user A and user B edit the same test case through different terminal devices, if user A finishes editing first, the edited test case can be saved. After user B finishes editing, when the server receives the save instruction sent by user B through the terminal device, the server will use the test case edited by user B to directly overwrite the test case edited by user A. In this way, the user will not be able to view the edit by user A. The completed test case. In addition, since the test case edited by user B will directly cover the test case edited by user A, if the accuracy of the test case edited by user B is not high, it will directly affect the accuracy of the final saved test case.

In consideration of the above problems, the embodiment of the present application proposes a method for processing test cases. In this method, when multiple people edit or modify the same test case at the same time, and save the modification after the modification is completed, if the There are saved test cases, that is, when there is a data conflict, the content modified by multiple people can be saved. For example, the content modified by multiple people can be saved in the same version of the test case for users to view. It can avoid the situation where the later saved test case directly overwrites the previously saved test case. In addition, when multiple testers modify the same test case, most of the modified contents may be the same. In order to save storage space, the contents modified by multiple people can be compared. If there is different data, that is, the modification is different When the content is changed, the target difference data can be determined from the difference data. Specifically, it can be displayed through the interface, and the tester can determine the part that needs to be retained according to the difference data. In this way, on the one hand, the test case saved later will not directly cover the test case saved before, and the user can also view the test case saved before. On the other hand, the user can select the part that needs to be kept according to the difference data, thereby improving the accuracy of the final saved test case.

Before describing the solution of the test case processing method of the present application, first understand the system architecture of the present application according to FIG. 1 .

FIG. 1 is a system architecture diagram of a method for processing a test case provided by an embodiment of the present application. As shown in FIG. 1 , the system includes: a first terminal device 101 , second

terminal devices

102 , 103 and 104 , and a server 105 . Among them, user A can edit or modify the test case through the first terminal device 101, users B, C and D can edit or modify the test case through the second

terminal device

102, 103 and 104 respectively, and the user can edit or modify the test case through the terminal device Alternatively, the modified test case may be stored in the database of the server 105, where the database may be a Redis database, a SQL database, or other types of databases, as long as the test case can be stored. In addition, the server 105 may be one server, or may be a distributed server cluster composed of multiple servers.

Taking the scenario of testing the system as an example, user A can use test case 1.1 to test the system through the terminal device 101, and can modify test case 1.1 during the test process. Similarly, user B, user C, and user D The test case 1.1 can be used to test the system through the

terminal devices

102, 103 and 104 respectively, and the test case 1.1 can be modified during the test. That is, multiple users can modify the same test case at the same time, and the users can send the modified test case to the server 105 through their corresponding terminal devices to save the modified test case of each user. In addition, in order to enable users to view the modifications made by other users to the test cases, the server 105 will compare the differences between the test cases and send the difference data when it is determined that at least two users have saved the test cases. Display it to the terminal device, so that the user can determine the test case he wants to save according to the difference data, so as to generate the target test case for saving. The target test case is used to test the system.

It should be understood that in the system architecture shown in FIG. 1 , the number of users, the first terminal device 101 , the second

terminal devices

102 , 103 and 104 and the server 105 is only exemplary, and more or less numbers belong to The scope of protection of this application. In addition, in the above example operation scenario, the user can use various devices to access the network, such as personal computer, server, tablet, mobile phone, PDA (Personal Digital Assistant, PDA), notebook or any other computing device with networking capabilities . The server 105 can be implemented using a server or server group with more powerful processing power and higher security. The above-mentioned network may include various types of wired and wireless networks, such as but not limited to: Internet, local area network, wireless fidelity (Wireless Fidelity, WIFI), wireless local area network (Wireless Local Area Networks, WLAN), cellular communication network (General Packet Wireless service technology (General Packet Radio Service, GPRS), Code Division Multiple Access (Code Division Multiple Access, CDMA), 2G/3G/4G/5G cellular network), satellite communication network, etc.

After understanding the system architecture of the present application, the solution of the processing method of the test case of the present application will be described in detail with reference to FIG. 2 .

FIG. 2 is a signaling diagram of a method for processing a test case provided by an embodiment of the present application. As shown in FIG. 2 , the method for processing a test case provided by the embodiment of the present application includes the following steps:

Step 201: If it is detected that the basic test case is in an unlocked state, the server obtains the test case to be saved and the latest test case saved in the database.

Among them, the test case to be saved and the latest test case are obtained by modifying the basic test case respectively.

In this step, the server can monitor whether the basic test case is in a locked state through webSocket.

The test case to be saved and the latest test case are obtained after different users modify the same basic test case. The modification completion time of the latest test case is earlier than the modification completion time of the test case to be saved. Therefore, the latest test case is the test case that has been modified and saved in the database, and the test case to be saved is the test case that needs to be saved currently.

It should be understood that when the server detects that the basic test case is in an unlocked state and a data conflict occurs, that is, when a user has modified and saved the test case, the server will obtain the test case to be saved and the saved test case in the database. The latest test cases for . Therefore, in a possible implementation manner, after receiving the second operation instruction triggered by the user for saving the test case to be saved, the first terminal device will send a third message to the server, where the third message includes The test case to be saved and the version ID of the test case to be saved. The server obtains the version ID of the latest test case according to the third message. If the version ID of the test case to be saved is different from the version ID of the latest test case, it is obtained from the database Latest test case.

Specifically, Fig. 3 is a schematic diagram of triggering the second operation instruction. As shown in Fig. 3, after the user modifies the basic test case through the terminal device, he can trigger the "Save" control on the operation interface to save the modified test case. The test case is saved, and the modified test case is the test case to be saved. When the terminal device receives the second operation instruction triggered by the user, it will carry the test case to be saved and the version identifier of the test case to be saved in a third message and send it to the server, and the server will obtain the stored data in the database according to the third message. Version ID of the latest test case.

Among them, the test case to be saved and the latest test case are obtained by modifying the basic test case of the same version. When the server saves the modified test case, if it determines that the version identifier of the test case to be saved is the same as the If the version ID of the latest test case stored in the database is the same, it means that no user has saved it before. At this time, there is no data conflict, then the server will modify the version ID of the test case to be saved according to the version ID of the latest test case, and Store test cases to be saved.

If the server determines that the version identifier of the test case to be saved is different from the version identifier of the latest test case stored in the database, it means that a user has saved the modified test case before. At this time, there is a data conflict, the server will The latest test case will be fetched from the database.

For example, user A and user B modify the basic test case with version 1.1 through different terminal devices. After user A's modification is completed, a save message will be sent to the server through the terminal device. The save message includes the user A modified test case and version ID 1.1, the server will obtain the version ID of the latest test case stored in the database. If the version ID of the latest test case is also 1.1, it means that no other user has modified the test case before. and save it, the server will automatically increment the version number as the version identifier of the current test case, for example, modify it to 1.2. At this time, the test case modified by user A is the latest test case saved in the database, and the latest test case’s The version ID is 1.2.

After the modification of user B is completed, a save message will be sent to the server through the corresponding terminal device. The save message includes the test case modified by user B and the version ID 1.1. The server will obtain the version ID of the latest test case stored in the database. , the version ID of the latest test case obtained at this time is 1.2. This version ID is different from the version ID of the test case to be saved, which means that other users have saved the test case before, and the server will obtain the version ID of 1.2. The latest test case, and the test case that needs to be saved after user B's modification is determined as the test case to be saved.

It should be noted that when the server updates the version identifier of the test case, it usually first determines whether it is the first version. If it is the first version, it will set the current version identifier for the test case, which is usually the default. The version identifier of the test case is 1.1, and the set version identifier is saved in the Version table of the database, and the version identifier is returned to the terminal device. In addition, after the content of the test case is created, all the information of the test case will be converted into Xml form as content storage, in which the version ID field will be set to the returned version ID Id and saved to the database Case Content table.

Further, if it is not the first version, query the version ID of the latest test case saved in the current database, and automatically increment the version number as the current version ID. The logic of the auto-increment version number is as follows: if yes If it is a small modification, the last digit will be incremented automatically, for example: from 1.1 to 1.2, if it is a major modification, the first digit will be incremented automatically, and the last digit will be reset to 1, for example: 2.1 will be added from 1.3. The determination of the above version number may be determined by the server according to the content modified by the user, or the user may send a modification message carrying the version number to the server through the terminal device, and the server may determine the modification message according to the version number in the modification message. definite.

In this embodiment, when the server determines that the version identifier of the test case to be saved is different from the version identifier of the latest test case, the server obtains the latest test case from the database to determine the difference between the test case to be saved and the latest test case. Difference data, thus avoiding the phenomenon of directly using the test case to be saved to cover the latest test case.

Step 202: The server determines at least one difference data between the test case to be saved and the latest test case, and a difference type corresponding to the difference data, where the difference type includes at least one of addition type, deletion type and modification type.

In this step, the server compares the obtained test case to be saved with the At least one variance data between the latest test cases and the variance type corresponding to each variance data. Among them, the difference data can also be understood as different data between the test case to be saved and the latest test case.

In a possible implementation manner, the test case to be saved and the latest test case may be compared to determine the longest common subsequence of the test case to be saved and the latest test case, and the test case to be saved and the latest test case are compared with the latest test case respectively. The longest common subsequence is compared, and the different data between the test case to be saved and the longest common subsequence, as well as the different data between the latest test case and the longest common subsequence, are determined as at least one difference data, and then A difference type corresponding to the difference data is determined according to the at least one difference data and the longest common subsequence.

Specifically, in the embodiment of the present application, at least one difference data between the test case to be saved and the latest test case, and the difference type corresponding to each difference data can be determined by the Myers difference algorithm.

Among them, the Myers difference algorithm is a text difference comparison algorithm. By comparing the differences between the new and old data sets, the minimum change from the old data to the new data is generated. Mainly to solve the longest common subsequence (Longest Common Subsequence, LCS) problem.

Specifically, the server first splits the test case to be saved and the latest test case into strings according to the content of each line, thereby obtaining two data sets, namely the original data set original and the revised data set revised. Then use the Myers difference algorithm implemented in the Google DiffUtils framework tool class to process the above data sets, that is, the input source data set original and the revised data set revised. After the algorithm operation, the LCS of each line of strings in the two data sets can be obtained, thus You can get the Delta list of difference information for each line. Each line of difference information Delta list includes a different string set original diff compared with each line of source data set original diff and a different string set revised diff compared with each line revised data set revised diff and the starting position of each line, and then The operation type is obtained according to the compared difference string information, that is, the difference type.

Among them, the Google DiffUtils framework tool class is a Myers difference algorithm implementation tool class provided by Google. By comparing two datasets, return a list of difference information Deltas objects. The Deltas object includes the character content and character position of each line of the source data and the comparison data, and the operation type obtained from the comparison, such as adding, modifying, and deleting.

For example, if the test case to be saved is "abcdefg" and the latest test case is "defghjk", by comparing the test case to be saved with the latest test case, the longest common value between the test case to be saved and the latest test case is determined. The subsequence LCS is "defg", then the LCS is compared with the test case "abcdefg" to be saved, the difference data is "abc", and the difference type is the deletion type, and the LCS is compared with the latest test case "defghjk", the difference data is is "hjk", and the difference type is the increase type.

Further, a list of the insertList addition type, the deleteList deletion type and the changeList modification type can be newly created in the server in advance, which are respectively used to save the classification information. After the difference data is obtained, each difference data and the corresponding difference type can be traversed in a loop, and each difference data is stored in a corresponding list for subsequent viewing by the user, thereby facilitating user operations and improving user experience.

In this embodiment, since the Myers difference algorithm has high performance when processing a large amount of data, the server determines, through the Myers difference algorithm, at least one difference data between the test case to be saved and the latest test case, and the difference between the test case and the latest test case. The difference type corresponding to the difference data can not only improve the efficiency of determining the difference data and the difference type, but also improve the accuracy.

Step 203: The server sends a first message to the first terminal device, where the first message includes difference data and a difference type.

In this step, after the server determines at least one difference data between the test case to be saved and the latest test case and the difference type corresponding to each difference data, in order to enable the user to intuitively browse the basic test case by other users through the terminal device For the modifications made, as well as the difference data and difference types between other users and the content modified by the user, the server may send the determined difference data and corresponding difference types in the first message to the first terminal device.

Exemplarily, in order to display the difference data of different difference types on the first terminal device in different forms, the server needs to process the difference data according to the difference types. For example, different types of difference data can be displayed in different colors. For example, the difference data of the deletion type can be displayed in red, the difference data of the added type can be displayed in green, the difference data of the modified type can be displayed in blue, etc. It should be understood that the same data between the test case to be saved and the latest test case can be displayed normally.

If the difference data of increasing type is displayed in green, the server can process the difference data in the following ways:

INSERT_TAG_BEGIN="<span style="background:rgba(0,191,165,0.16);display:inline-block'>";

INSERT_TAG_END="</span>";

If the difference data of deletion type is displayed in red, the server can process the difference data in the following ways:

DELETE_TAG_BEGIN="<span style="background:rgba(226,59,59,0.16);display:inline-block'>";

DELETE_TAG_END="</span>"

In addition, if it is a deletion type, you can select the character list of the original diff in dalta, and add DELETE_TAG_BEGIN and DELET_TAG_END before and after each character.

If it is an increase type, you can select the character list of revised diff in dalta, and add INSERT_TAG_BEGIN and INSERT_TAG_END before and after each character.

If it is a modification type, you can select the original diff and revised diff character lists in dalta, and deal with the deletion and new content marks of the two respectively.

The server splices all processed character lists in sequence through the position field to generate new content, and sends it to the first terminal device.

Exemplarily, after receiving the first message, the first terminal device parses and processes the difference data in the first message, and displays the difference data in different ways according to different types of differences.

For example, Fig. 4 is a schematic diagram of the display of difference data, assuming that the test case to be saved is "abcdefg", the latest test case is "defghjk", and it is determined that the difference data between the test case to be saved and LCS is "abc", and the difference The type is the deletion type, the difference data of the latest test case compared with the LCS is "hjk", and the difference type is the addition type. As shown in Figure 4, the first terminal device will splicing and display the difference data. For example, the difference data of the deletion type can be displayed with a diagonal line as the background, and the difference data of the added type can be displayed with the horizontal line as the background. Yes, the difference data of the modification type can be displayed in other backgrounds, as long as it can be distinguished from the data of the deletion type and the addition type. Of course, different difference data and difference types can also be distinguished in other ways. For example, different colors can be used to display according to the difference type. For example, the difference data of the deletion type can be displayed in red, and the difference data of the added type can be displayed. In green, the difference data of the modification type can be displayed in blue, etc. It should be understood that the same data between the test case to be saved and the latest test case can be displayed normally.

Step 204: The first terminal device determines target difference data and a target difference type corresponding to the target difference data, where the target difference data is data in at least one difference data.

In this step, after receiving the difference data, the first terminal device can display the difference data and the corresponding difference type to the user, and the user can select the data that he wants to keep according to his own needs. Therefore, the first terminal device will be triggered through the display interface. An operation instruction, the first operation instruction includes target difference data selected by the user from at least one difference data, and a target difference type corresponding to the target difference data.

For example, continuing to refer to Figure 4b, if the user wants to keep the difference data "hjk" in the final test case, the difference data "hjk" can be determined as the target difference data, and the difference type of the target difference data is increase type. The user triggers the first operation instruction by clicking "hjk". Of course, the user can also trigger the first operation instruction by long pressing or other operation methods.

In addition, after receiving the difference data and the difference type, the first terminal device may also determine the target difference data and the target difference type corresponding to the target difference data from the difference data through a preset rule. For example, all the difference data whose difference type is an increase type are determined as the target difference type, and so on.

Step 205: The first terminal device sends a second message to the server, where the second message includes target difference data and a target difference type corresponding to the target difference data.

In this step, after determining the target difference data and the corresponding target difference type, the first terminal device will send a second message to the server.

Exemplarily, after receiving the first operation instruction triggered by the user, the first terminal device carries the target difference data selected by the user and the target difference type corresponding to the target difference data in a second message and sends it to the server. The target difference data may include part of the difference data, or may include all the difference data.

Exemplarily, the first terminal device may also carry the target difference data determined according to the preset rule and the target difference type corresponding to the target difference data in the second message and send it to the server.

Step 206: The server generates a target test case according to the target difference data, the target difference type and the latest test case.

In this step, the server generates a target test case according to the received target difference data, the target difference type corresponding to the target difference data, and the latest test case saved in the database, and saves the target test case. Since the tester can select the target difference data from at least one difference data to save according to their own needs, instead of using the test case saved later to cover the test case saved earlier, the accuracy of the target test case can be improved.

In a possible implementation manner, when the server generates the target test case, if the target difference data corresponding to the target difference type is determined as the data in the latest test case, the latest test case is determined as the target test case.

Specifically, if the target difference data is the data obtained by modifying the basic test case in the latest test case, at this time, it means that the difference data that the user wants to save is all the data in the latest test case. Therefore, the latest test case can be Use cases are identified as target test cases.

Exemplarily, if it is determined that the target difference data corresponding to the target difference type is the data in the test case to be saved, in the latest test case, an operation corresponding to the target difference type is performed on the target difference data to generate the target test case. .

Specifically, if the target difference data is the data obtained by modifying the basic test case in the test case to be saved, at this time, it indicates that the difference data that the user wants to save is all the data in the test case to be saved. In the latest test case, the operation corresponding to the target difference type is performed on the target difference data. For example, if the target difference type is an add type, you can add the target difference data in the latest test case. If the target difference type is a delete type, you can delete the target difference data in the latest test case. If the target difference type is Modification type, the target difference data can be modified in the latest test case.

Exemplarily, if it is determined that the first data in the target difference data is the data in the latest test case, and the second data is the data in the test case to be saved, then keep the first data and the first data in the latest test case. The difference type corresponding to the data remains unchanged, and in the latest test case, an operation corresponding to the difference type of the second data is performed on the second data to generate the target test case.

Specifically, if the target difference data determined by the first terminal device includes multiple data, and a part of the first data is the data in the latest test case, the server will keep this part of the difference data unchanged, that is, in the latest test case continue to retain this part of the first data. Another part of the second data is the data in the test case to be saved, then the server will perform corresponding operations on the second data in the latest test case according to the difference type corresponding to the second data, such as adding, deleting or modifying, thereby generating target test case.

In this embodiment, the server can generate the target test case according to the target difference data determined by the first terminal device, the target difference type corresponding to the target difference data, and the latest test case, thereby improving the accuracy of the target test case. In addition, if the first data in the target difference data is the data in the latest test case, and the second data is the data in the test case to be saved, the generated target test case includes the data modified by the user himself, and also includes Data modified by other users, thus avoiding the phenomenon that the later saved test case directly overwrites the previously saved test case.

In the test case processing method provided by the embodiment of the present application, when it is detected that the basic test case is in an unlocked state, the test case to be saved and the latest test case saved in the database are obtained by obtaining the test case to be saved and the latest test case to be saved. at least one difference data of the use case, and the difference type corresponding to the difference data, and then send a first message to the first terminal device, the first message includes the difference data and the difference type by receiving the second message sent by the first terminal device, The second message includes the target difference data and the target difference type corresponding to the target difference data, and generates the target test case according to the target difference data, the target difference type and the latest test case. Since the server determines at least one difference data between the test case to be saved and the latest test case when saving the test case to be saved, and determines the target difference data from the at least one difference data by the first terminal device and the corresponding target difference type , to generate target test cases, thereby avoiding the phenomenon in the prior art that the previously saved test cases are directly used after being used to cover the previously saved test cases, and the difference data can be selectively saved, thereby improving the accuracy of the target test cases.

FIG. 5 is another signaling diagram of a method for processing a test case provided by an embodiment of the present application. On the basis of the embodiment shown in FIG. 2, the embodiment shown in FIG. When editing, the process of how to resolve editing conflicts will be explained in detail. As shown in FIG. 5 , the processing method of the test case provided by the embodiment of the present application includes the following steps:

Step 501: The first terminal device receives a third operation instruction triggered by the user, where the third operation instruction includes the version identifier of the basic test case to be locked.

Specifically, when the user edits the basic test case, the first terminal device will send the version ID curVersionId of the currently edited basic test case and the data of the basic test case to the server to store in the database redis. If the user does not want other users to edit the basic test case at the same time, he can choose to lock the basic test case. Figure 6 is a schematic diagram of triggering the third operation instruction. As shown in Figure 6, the user is editing the test case "aabbccdd", and he can choose to lock the test case according to his own needs, for example, he can click "Lock" control to trigger a third operation instruction, where the third operation instruction includes the version identifier of the basic test case to be locked, such as the version identifier curVersionId of the test case "aabbccdd".

Among them, if the user chooses to lock the basic test case, it means that currently only the user can edit the basic test case, while other users can only read but not write, and the test case editing page of the terminal device corresponding to other users is displayed. , it will show that the basic test case has been locked or locked by the user, etc.

Step 502: The first terminal device sends a fourth message to the server according to the third operation instruction, where the fourth message includes the version identifier of the basic test case to be locked.

In this step, after receiving the third operation instruction triggered by the user, the first terminal device will carry the version identifier of the basic test case to be locked in a fourth message and send it to the server.

Step 503: According to the fourth message, the server, when detecting that the basic test case corresponding to the first terminal device is in a locked state, sends a locking message to the second terminal device other than the first terminal device, where the locking message includes the pending test case. The version identifier of the locked basic test case, and the locking message is used to instruct the second terminal device to set the to-be-locked basic test case corresponding to the second terminal device to a locked state.

In this step, if the server determines that the basic test case is in the locked state according to the fourth message received, it means that the user does not want other users to edit the basic test case at this time. The version identifier is carried in the lock message and sent to the second terminal device. In this way, the second terminal device will set the basic test case to be locked into a locked state. The tester will not be able to edit the locked basic test case through the second terminal device, but can only view the locked basic test case.

In this embodiment, the user can lock the basic test case to be locked according to his own needs, so that other users cannot edit the basic test case to be locked, thereby avoiding the phenomenon of data conflict in the test case.

Further, when the preset conditions are met, the server will send an unlock message to the second terminal device, the unlock message includes the version identifier of the basic test case in the locked state, the unlock message is used to instruct the generation of the first value, and indicates The second terminal device unlocks the basic test case in the locked state when judging that the first value is the same as the pre-stored second value; the preset condition includes that the locking duration of the basic test case in the locked state exceeds the preset duration, and /or, a fifth message sent by the first terminal device is received, where the fifth message is used to indicate that the basic test case in the locked state is saved.

Specifically, the server may send an unlocking message to the second terminal device when monitoring through webSocket that the locking duration of the basic test case in the locked state exceeds the preset duration, so that the second terminal device will send an unlocking message to the second terminal device according to the unlocking message. , to unlock the basic test case in the locked state, thereby preventing the phenomenon that the test case has been edited by a user all the time, thereby improving the user experience.

In addition, if the user finishes editing the basic test case in the locked state, a fourth operation instruction may be triggered to save the edited basic test case. After receiving the fourth operation instruction triggered by the user, the first terminal device will send a fifth message to the server, and the server will send an unlock message to the second terminal device according to the received fifth message, so that the second terminal device will send an unlock message to the second terminal device according to the received fifth message. The unlock message unlocks the test case in the locked state, so that other users can continue to edit the test case, which improves the user experience.

In addition, the above-mentioned preset condition may also be that the server monitors through webSocket that the lock duration of the test case in the locked state exceeds the preset duration, and when receiving the fifth message sent by the first terminal device, the server sends an unlock message to the second terminal device .

Further, the preset condition may further include that the server monitors through the webSocket that the first terminal device exits the interface for editing the test case in the locked state.

The following describes how the server implements distributed locks and unlocks. Among them, distributed locks refer to when there is only one copy (or limited) of data in a distributed system, and the lock technology needs to be used to control a certain The number of processes that modify data at any time.

Specifically, the server can implement distributed locks based on redis. Exemplarily, it can be implemented based on the following redis commands: SET key value[EX seconds][PX milliseconds][NX|XX], where EX seconds represents the expiration time, in units of is seconds, PX milliseconds represents the expiration time in milliseconds, NX is the value set only when the key does not exist, and XX is the value set only when the key exists.

The implementation idea is: when acquiring the lock, the version ID of the test case to be locked is spliced with "_LOCK" as the key, and the value of the lock is a randomly generated unique identifier (Universally Unique Identifier, UUID). The value can determine whether the lock is own when the lock is released. In addition, by setting the parameter NX, and adding a timeout time expire Time Units to the lock, if the monitoring of the lock status is overtime, the lock will be released automatically, that is, when there is no operation for a long time or the locked test case is edited, the lock will be released automatically.

When the second terminal device releases the lock, it will randomly generate the first value value. When it is judged that the first value is the same as the second value stored in advance, it can determine that the lock is its own, so as to execute the operation of releasing the lock. . In this application, when releasing the lock, the method of deleting the key is not directly used, because the method of directly deleting the key will cause all the second terminal devices to be unlocked, which will cause some test cases that do not need to be unlocked to be unlocked, resulting in Bad user experience.

Exemplarily, Fig. 6 is a schematic diagram of locking and unlocking the test case to be locked. As shown in Fig. 6, if the system includes a distributed server cluster, that is, includes multiple servers A, B and C, the distributed The redis component in the server cluster can cache the version information of the test case and the content of the test case. The server cluster will determine a server from the server cluster to establish a webSocket connection with the first terminal device according to the version identification and user identification (ID) of the test case to be locked. For example, it can be determined that server B establishes a webSocket connection with the first terminal device. Server B can store the connected webSocket according to onOpen, obtain the content of the test case in redis according to the version information of the test case, and send it to the first terminal device. In addition, the established webSocket connection can also be removed according to onClose, and the unlock information of the version information of the test case is stored, and stored in redis, and an unlock message is sent to the second terminal device at the same time. Server B can also monitor the information sent by the first terminal device according to onMessage, and lock or unlock the test case in redis, for example, monitor whether the first terminal device currently quits editing the test case, or whether the test case is triggered Save the message, or monitor whether the editing time of the test case by the user through the first terminal device times out, and so on.

For the first terminal device, when establishing a webSocket connection with the server, the webSocket needs to be initialized first. Exemplarily, webSocket initialization may be implemented in the following manner: webSocket=new webSocket(SocketUrl+“/webSocket/”+contentId+“/”+username). After the initialization is completed, it will monitor the status information of the basic test case to be locked sent by the server through webSocket.onMessage, and display whether it needs to be locked according to the status information of the basic test case to be locked. In addition, you can also send the status information of the basic test case to be locked to the server through webSocket.send (status information of the test case to be locked) to notify the server that the basic test case to be locked needs to be locked, or you can use webSocket.send (Status information of the test case in the locked state) Send the state information of the basic test case in the locked state to the server to notify the server that the basic test case in the locked state needs to be unlocked. Further, the first terminal device can also monitor the state of the server through webSocket.onclose, so as to process the disconnection and reconnection operation after the server is interrupted.

In this embodiment of the present application, when detecting that the basic test case corresponding to the first terminal device is in a locked state, the server may control to lock the basic test case on the second terminal device, thereby preventing multiple users from simultaneously When the basic test case is edited, the phenomenon of data conflict is caused. Further, when it is determined that the preset condition is met, the server will send an unlock message to the second terminal device to unlock the basic test case in the locked state, so as to ensure that other users can also continue to edit the basic test case. Improve user experience.

Further, on the basis of the above embodiments, the version of the test case modified by each user can also be saved, so that the user can query the data of all historical versions of the test case modified by the user according to the version identifier. Exemplarily, if the user chooses to roll back and view a test case of a previous version, the server will copy the test case data of the historical version and generate a new test case, thereby creating the test case content and saving it as a new test case. version ID.

In this embodiment, not only can the target test case be generated according to the difference data, but also all the test cases modified by the user can be saved, so that the user can conveniently view the test cases of any historical version, thereby improving the user experience .

FIG. 7 is another signaling diagram of a method for processing a test case provided by an embodiment of the present application. As shown in FIG. 7 , the method includes:

Step 701: The first terminal device receives a fifth operation instruction triggered by the user, where the fifth operation instruction is used to indicate whether the test case needs to be locked.

The user can edit the test case through the first terminal device. If the user needs to edit the test case to be locked by one person according to his own needs, he can send a fifth operation instruction to the first terminal device. The fifth operation instruction The instruction is used to indicate that the test case needs to be locked, and the fifth operation instruction includes the version identifier of the test case to be locked, wherein the triggering method and implementation principle of the fifth operation instruction are the same as the third operation instruction in the foregoing embodiment. similar, and will not be repeated here.

If the fifth operation instruction is used to indicate that the test case does not need to be locked, it means that the test case allows multiple people to edit at the same time.

Wherein, if the test case needs to be locked, step 702 is performed; otherwise, step 705 is performed.

Step 702: The first terminal device sends a fourth message to the server, where the fourth message includes the version identifier of the test case to be locked.

Step 703: The server sends a lock message to the second terminal device other than the first terminal device according to the fourth message, where the lock message includes the version identifier of the test case to be locked, and the lock message is used to indicate that the second terminal device will Locked test cases are set to locked state.

Step 704: The server monitors whether the preset conditions are met, and when the preset conditions are met, sends an unlock message to the second terminal device, where the unlock message includes the version identifier of the test case in the locked state, and the unlock message is used to indicate the first The second terminal device unlocks the test case in the locked state.

The preset conditions include at least one of the following: the lock duration of the test case in the locked state exceeds the preset duration, the fifth message sent by the first terminal device is received, and the test case in the locked state is monitored after the first terminal device exits editing interface.

If it is monitored that the first terminal device does not meet the preset condition, the user will wait for the user to continue editing the test case through the first terminal device, and when the preset condition is met, the locked test case will be unlocked.

In addition, when the user saves the edited test case through the first terminal device, the first terminal device will send the edited test case to the server, and the server will create a new version of the test case and save the test case.

Step 705: The first terminal device sends a third message to the server, where the third message includes the test case to be saved and the version identifier of the test case to be saved.

Wherein, if the same test case allows multiple people to edit at the same time, when a user completes the editing and saves it, a third message will be sent to the server through the first terminal device.

Step 706: The server obtains the version identifier of the latest test case according to the third message.

Step 707: If the server determines that the version identifier of the test case to be saved is different from the version identifier of the latest test case, the server obtains the latest test case from the database.

Among them, if the version identifier of the test case to be saved is different from the version identifier of the latest test case, it means that a user has edited and saved the test case before, that is, there is a data conflict, at this time, it needs to be obtained from the database. Latest test case.

Step 708: The server determines at least one difference data between the test case to be saved and the latest test case, and the difference type corresponding to the difference data.

The difference type includes at least one of an addition type, a deletion type, and a modification type.

Step 709: The server sends a first message to the first terminal device, where the first message includes difference data and the difference type.

Step 710: The first terminal device displays the difference data and the difference type.

Step 711: The first terminal device receives a first operation instruction triggered by the user, the first operation instruction includes target difference data and a target difference type corresponding to the target difference data, and the target difference data is data in at least one difference data.

Step 712: The first terminal device sends a second message to the server according to the first operation instruction, where the second message includes the target difference data and the target difference type.

Step 713: The server generates a target test case according to the target difference data, the target difference type and the latest test case.

Among them, after the server generates the target test case, it will create a new version identifier for the target test case and save it.

In the test case processing method provided by the embodiment of the present application, on the one hand, when the server saves the test case to be saved, it determines at least one difference data between the test case to be saved and the latest test case, and selects the difference data from the at least one difference data according to the user. The selected target difference data and the corresponding target difference type are used to generate target test cases, thereby avoiding the phenomenon that the test cases saved before being directly adopted in the prior art overwrite the previously saved test cases, and users can choose according to their own needs. The difference data is saved so that the accuracy of the target test case can be improved. On the other hand, the server can lock the test case according to the demand information sent by the user, which can avoid data conflicts caused when multiple people edit the same test case at the same time.

FIG. 8 is a schematic diagram of a processing device for a test case provided by an embodiment of the present application. As shown in FIG. 8 , the processing device 80 for the test case includes:

The processing module 801 is configured to acquire the test case to be saved and the latest test case saved in the database, the test case to be saved and the latest test case are obtained by modifying the basic test case respectively;

The processing module 801 is further configured to determine at least one difference data between the test case to be saved and the latest test case, and a difference type corresponding to the difference data, and the difference type includes an addition type, a deletion type, and a difference type. at least one of the modification types;

A sending module 802, configured to send a first message to a first terminal device, where the first message includes the difference data and the difference type, and the first message is used to instruct the first terminal device to display the difference discrepancy data and the type of discrepancy;

A receiving module 803, configured to receive a second message sent by the first terminal device, where the second message includes target difference data and a target difference type corresponding to the target difference data, and the target difference data is the data in at least one difference data;

The processing module 801 is further configured to generate a target test case according to the target difference data, the target difference type and the latest test case.

Optionally, the processing module 801 is specifically used for:

At least one difference data between the test case to be saved and the latest test case, and a difference type corresponding to the difference data are determined by the Myers difference algorithm.

Optionally, the processing module 801 is specifically used for:

Optionally, the receiving module 803 is further configured to receive a fourth message sent by the first terminal device, where the fourth message includes a version identifier of the test case to be locked;

The sending module 802 is further configured to send a lock message to a second terminal device other than the first terminal device according to the fourth message, where the lock message includes the version identifier of the test case to be locked , the lock message is used to instruct the second terminal device to set the to-be-locked test case to a locked state.

Optionally, the sending module 802 is further configured to send an unlock message to the second terminal device when a preset condition is met, where the unlock message includes the version identifier of the test case in the locked state, and the unlock message The message is used to instruct the second terminal device to unlock the test case in the locked state; the preset condition includes that the locking duration of the test case in the locked state exceeds the preset duration, and/or receiving all The fifth message sent by the first terminal device is used to indicate that the test case in the locked state is saved.

The test case processing device 80 provided in the embodiment of the present application can execute the technical solution of the test case processing method in any of the above embodiments, and its implementation principle and beneficial effects are similar to the implementation principle and beneficial effects of the test case processing method , please refer to the implementation principle and beneficial effect of the processing method of the test case, which will not be repeated here.

FIG. 9 is a schematic diagram of a processing device for a test case provided by an embodiment of the present application. As shown in FIG. 9 , the processing device 90 for the test case includes:

The receiving module 901 is configured to receive a first message sent by the server, where the first message includes at least one difference data and a difference type corresponding to each difference data, and the difference data is the difference between the test case to be saved and the latest test case The difference data of the test case to be saved and the latest test case are obtained by modifying the basic test case;

a display module 902, configured to display the difference data and the difference type;

The receiving module 901 is further configured to receive a first operation instruction triggered by a user, where the first operation instruction includes target difference data and a target difference type corresponding to the target difference data, and the target difference data is the data in at least one difference data;

The sending module 903 is configured to send the second message to the server according to the first operation instruction, where the second message includes the target difference data and the target difference type, and the second message uses for instructing the server to generate a target test case according to the target difference data, the target difference type and the latest test case.

Optionally, the receiving module 901 is further configured to receive a second operation instruction triggered by a user, where the second operation instruction is used to save the to-be-saved test case;

The sending module 903 is further configured to send a third message to the server according to the second operation instruction, where the third message includes the test case to be saved and the version identifier of the test case to be saved, The third message is used to instruct the server to obtain the version identifier of the latest test case, and obtain from the database when the version identifier of the test case to be saved is different from the version identifier of the latest test case The latest test case described.

Optionally, the receiving module 901 is further configured to receive a third operation instruction triggered by the user, where the third operation instruction includes the version identifier of the test case to be locked;

The sending module 903 is further configured to send a fourth message to the server according to the third operation instruction, where the fourth message includes the version identifier of the test case to be locked, and the fourth message is used to indicate the The server sends a lock message to a second terminal device other than the terminal device, where the lock message includes the version identifier of the test case to be locked, and the lock message is used to instruct the second terminal device to The test case to be locked is set to the locked state.

Optionally, the receiving module 901 is further configured to receive a fourth operation instruction triggered by the user, where the fourth operation instruction is used to instruct to save the test case in the locked state;

The sending module 903 is further configured to send a fifth message to the server according to the fourth operation instruction, where the fifth message is used to instruct the server to send an unlock message to the second terminal device, the The unlock message includes the version identifier of the test case in the locked state, and the unlock message is used to instruct the second terminal device to unlock the test case in the locked state.

The device 90 for processing test cases provided by the embodiments of the present application can execute the technical solutions of the methods for processing test cases in any of the above embodiments, and its implementation principle and beneficial effects are similar to those of the method for processing test cases. , please refer to the implementation principle and beneficial effect of the processing method of the test case, which will not be repeated here.

It should be noted that it should be understood that the division of each module of the above device is only a division of logical functions, and may be fully or partially integrated into a physical entity in actual implementation, or may be physically separated. And these modules can all be implemented in the form of software calling through processing elements; they can also all be implemented in hardware; some modules can also be implemented in the form of calling software through processing elements, and some modules can be implemented in hardware. For example, the determination module may be a separately established processing element, or it may be integrated into a certain chip of the above-mentioned device, and in addition, it may be stored in the memory of the above-mentioned device in the form of program code, and a certain processing element of the above-mentioned device may be used for the determination module. Call and execute the function of the above processing module. The implementation of other modules is similar. In addition, all or part of these modules can be integrated together, and can also be implemented independently. The processing element described here may be an integrated circuit with signal processing capability. In the implementation process, each step of the above-mentioned method or each of the above-mentioned modules can be completed by an integrated logic circuit of hardware in the processor element or an instruction in the form of software.

For example, the above modules may be one or more integrated circuits configured to implement the above methods, such as: one or more application specific integrated circuits (ASIC), or one or more microprocessors (digital) signal processor, DSP), or, one or more field programmable gate arrays (field programmable gate array, FPGA), etc. For another example, when a certain module above is implemented in the form of a processing element dispatcher code, the processing element may be a general-purpose processor, such as a central processing unit (central processing unit, CPU) or other processors that can invoke program codes. For another example, these modules can be integrated together and implemented in the form of a system-on-a-chip (SOC).

In the above-mentioned embodiments, it may be implemented in whole or in part by software, hardware, firmware or any combination thereof. When implemented in software, it can be implemented in whole or in part in the form of a computer program product. The computer program product includes one or more computer instructions. When the computer program instructions are loaded and executed on a computer, all or part of the processes or functions described in the embodiments of the present application are generated. The computer may be a general purpose computer, special purpose computer, computer network, or other programmable device. The computer instructions may be stored in or transmitted from one computer-readable storage medium to another computer-readable storage medium, for example, the computer instructions may be downloaded from a website site, computer, server, or data center Transmission to another website site, computer, server, or data center is by wire (eg, coaxial cable, optical fiber, digital subscriber line (DSL)) or wireless (eg, infrared, wireless, microwave, etc.). The computer-readable storage medium can be any available medium that can be accessed by a computer or a data storage device such as a server, a data center, or the like that includes an integration of one or more available media. The usable media may be magnetic media (eg, floppy disks, hard disks, magnetic tapes), optical media (eg, DVDs), or semiconductor media (eg, solid state disks (SSDs)), and the like.

FIG. 10 is a schematic structural diagram of an embodiment of a server according to an embodiment of the present application. As shown in FIG. 10 , the server may include: a processor 1001 , a memory 1002 , a communication interface 1003 and a system bus 1004 , the memory 1002 and the communication interface 1003 are connected to the processor 1001 through the system bus 1004 and To complete the mutual communication, the memory 1002 is used to store computer execution instructions, the communication interface 1003 is used to communicate with other devices, and the processor 1001 implements the tests shown in the above embodiments when executing the computer program The technical solution of the processing method of the use case.

In FIG. 10 , the above-mentioned processor 1001 can be a general-purpose processor, including a central processing unit CPU, a network processor (NP), etc.; it can also be a digital signal processor DSP, an application-specific integrated circuit ASIC, a field-based processor, etc. Program a gate array FPGA or other programmable logic device, discrete gate or transistor logic devices, discrete hardware components.

The memory 1002 may include random access memory (RAM), may include read-only memory (RAM), and may also include non-volatile memory (non-volatile memory), such as at least one disk memory.

The communication interface 1003 is used to realize the communication between the database access device and other devices (eg client, read-write library and read-only library).

The system bus 1004 may be a peripheral component interconnect (PCI) bus or an extended industry standard architecture (EISA) bus, or the like. The system bus can be divided into address bus, data bus, control bus and so on. For ease of presentation, only one thick line is used in the figure, but it does not mean that there is only one bus or one type of bus.

FIG. 11 is a schematic structural diagram of an embodiment of a terminal device according to an embodiment of the application. As shown in FIG. 11 , the terminal device may include: a processor 1101 , a memory 1102 , a communication interface 1103 and a system bus 1104 , the memory 1102 and the communication interface 1103 are connected to the processor 1101 through the system bus 1104 and complete the mutual communication, the memory 1102 is used to store computer execution instructions, the communication interface 1103 is used to communicate with other devices, and the processor 1101 implements the above-mentioned embodiments when executing the computer program. The technical scheme of the processing method of the test case.

In FIG. 11 , the above-mentioned processor 1101 can be a general-purpose processor, including a central processing unit CPU, a network processor (NP), etc.; it can also be a digital signal processor DSP, an application-specific integrated circuit ASIC, a field Program a gate array FPGA or other programmable logic device, discrete gate or transistor logic devices, discrete hardware components.

The memory 1102 may include random access memory (RAM), may also include read-only memory (RAM), and may also include non-volatile memory (non-volatile memory), such as at least one disk memory.

The communication interface 1103 is used to realize the communication between the database access device and other devices (eg client, read-write library and read-only library).

The system bus 1104 may be a peripheral component interconnect (PCI) bus or an extended industry standard architecture (EISA) bus, or the like. The system bus can be divided into address bus, data bus, control bus and so on. For ease of presentation, only one thick line is used in the figure, but it does not mean that there is only one bus or one type of bus.

Optionally, an embodiment of the present application further provides a computer-readable storage medium, where computer instructions are stored in the computer-readable storage medium, and when the computer instructions are executed on a computer, the computer can be executed as shown in the foregoing embodiments. The technical scheme of the processing method of the test case.

Optionally, an embodiment of the present application further provides a chip for running an instruction, where the chip is used to execute the technical solution of the processing method of the test case shown in the foregoing embodiment.

An embodiment of the present application further provides a program product, where the program product includes a computer program, the computer program is stored in a computer-readable storage medium, and at least one processor can read the computer from the computer-readable storage medium A program, when the at least one processor executes the computer program, the technical solutions of the test case processing methods shown in the foregoing embodiments can be implemented.

Other embodiments of the present disclosure will readily occur to those skilled in the art upon consideration of the specification and practice of the applications disclosed herein. This application is intended to cover any variations, uses, or adaptations of the present disclosure that follow the general principles of the present disclosure and include common knowledge or techniques in the technical field not disclosed by the present disclosure . The specification and examples are to be regarded as exemplary only, with the true scope and spirit of the disclosure being indicated by the following claims.

It is to be understood that the present disclosure is not limited to the precise structures described above and illustrated in the accompanying drawings, and that various modifications and changes may be made without departing from the scope thereof. The scope of the present disclosure is limited only by the appended claims.

Claims

A test case processing method, characterized in that, applied to a server, the method comprising:

If it is detected that the basic test case is in an unlocked state, the test case to be saved and the latest test case saved in the database are obtained, and the test case to be saved and the latest test case are respectively modified for the basic test case obtained after

determining at least one difference data between the to-be-saved test case and the latest test case, and a difference type corresponding to the difference data, where the difference type includes at least one of an addition type, a deletion type, and a modification type;

Send a first message to a first terminal device, where the first message includes the difference data and the difference type; receive a second message sent by the first terminal device, where the second message includes target difference data and a target difference type corresponding to the target difference data, the target difference data being data in the at least one difference data;

A target test case is generated according to the target difference data, the target difference type and the latest test case.
The method according to claim 1, wherein the acquiring the test case to be saved and the latest test case saved in the database comprises:

receiving a third message sent by the first terminal device, where the third message includes the test case to be saved and the version identifier of the test case to be saved;

obtaining the version identifier of the latest test case according to the third message;

If the version identifier of the test case to be saved is different from the version identifier of the latest test case, the latest test case is acquired from the database.
The method according to claim 1, wherein the determining at least one difference data between the test case to be saved and the latest test case, and the difference type corresponding to the difference data, comprises:

Compare the test case to be saved with the latest test case, and determine the longest common subsequence of the test case to be saved and the latest test case;

Comparing the test case to be saved and the latest test case with the longest common subsequence respectively, comparing the different data between the test case to be saved and the longest common subsequence, and the The difference data between the latest test case and the longest common subsequence is determined as the at least one difference data;

According to the at least one difference data and the longest common subsequence, a difference type corresponding to the difference data is determined.
The method according to any one of claims 1-3, wherein the generating the target test case according to the target difference data, the target difference type and the latest test case, comprises:

If it is determined that the target difference data corresponding to the target difference type is data in the latest test case, then the latest test case is determined to be the target test case; or,

If it is determined that the target difference data corresponding to the target difference type is the data in the test case to be saved, then in the latest test case, the target difference data corresponding to the target difference type is performed operations to generate the target test case; or,

If it is determined that the first data in the target difference data is the data in the latest test case, and the second data is the data in the to-be-saved test case, keep the first data in the latest test case A piece of data and a difference type corresponding to the first data remain unchanged, and in the latest test case, an operation corresponding to the difference type of the second data is performed on the second data to generate the target test case.
The method according to any one of claims 1-3, wherein the method further comprises:

If it is detected that the basic test case corresponding to the first terminal device is in a locked state, a lock message is sent to a second terminal device other than the first terminal device, where the lock message includes the basic test case The lock message is used to instruct the second terminal device to set the basic test case corresponding to the second terminal device to a locked state.
The method according to claim 5, wherein the method further comprises:

When the preset condition is met, an unlock message is sent to the second terminal device, where the unlock message includes the version identifier of the basic test case in the locked state, the unlock message is used to instruct the generation of the first value and the The second terminal device unlocks the basic test case in the locked state when judging that the first value is the same as the pre-stored second value; the preset condition includes the basic test case in the locked state. The locking duration exceeds a preset duration, and/or a fifth message sent by the first terminal device is received, where the fifth message is used to indicate that the basic test case in the locked state is saved.
A method for processing a test case, characterized in that it is applied to a terminal device, the method comprising:

Receive the first message sent by the server, the first message includes at least one difference data and the difference type corresponding to each difference data, the difference data is the difference data between the test case to be saved and the latest test case, the The test case to be saved and the latest test case are obtained by modifying the basic test case;

determining target difference data and a target difference type corresponding to the target difference data, where the target difference data is data in the at least one difference data;

Send a second message to the server, where the second message includes the target difference data and the target difference type, and the second message is used to instruct the server to use the target difference data, the target difference Type and the latest test case, generate the target test case.
The method according to claim 7, wherein the determining the target difference data and the target difference type corresponding to the target difference data comprises:

displaying the difference data and the difference type;

A first operation instruction triggered by a user is received, where the first operation instruction includes the target difference data and the target difference type.
The method according to claim 7, wherein the method further comprises:

receiving a second operation instruction triggered by the user, where the second operation instruction is used to save the to-be-saved test case;

According to the second operation instruction, a third message is sent to the server, where the third message includes the test case to be saved and the version identifier of the test case to be saved, and the third message is used to indicate the test case to be saved. The server acquires the version identifier of the latest test case, and when the version identifier of the test case to be saved is different from the version identifier of the latest test case, acquires the latest test case from the database.
The method according to any one of claims 7-9, wherein the method further comprises:

Receive a third operation instruction triggered by the user, where the third operation instruction includes the version identifier of the basic test case to be locked;

According to the third operation instruction, a fourth message is sent to the server, where the fourth message includes the version identifier of the basic test case to be locked, and the fourth message is used to instruct the server to send the A second terminal device other than the terminal device sends a lock message, where the lock message includes the version identifier of the basic test case to be locked, and the lock message is used to instruct the second terminal device to The basic test case to be locked corresponding to the terminal device is set to a locked state.
The method of claim 10, wherein the method further comprises:

receiving a fourth operation instruction triggered by the user, where the fourth operation instruction is used to instruct to save the basic test case in the locked state;

According to the fourth operation instruction, a fifth message is sent to the server, where the fifth message is used to instruct the server to send an unlocking message to the second terminal device, where the unlocking message includes the basic information in a locked state The version identifier of the test case, the unlock message is used to instruct the generation of the first value, and instruct the second terminal device to lock the device in the locked state when judging that the first value is the same as the pre-stored second value. Basic test cases are unlocked.
A processing device for a test case, characterized in that it includes:

The processing module is used to obtain the test case to be saved and the latest test case saved in the database when it is detected that the basic test case is in an unlocked state, and the test case to be saved and the latest test case are for the basic test case respectively. After the use case is modified;

The processing module is further configured to determine at least one difference data between the test case to be saved and the latest test case, and a difference type corresponding to the difference data, where the difference type includes addition type, deletion type and modification at least one of the types;

a sending module, configured to send a first message to a first terminal device, where the first message includes the difference data and the difference type;

A receiving module, configured to receive a second message sent by the first terminal device, where the second message includes target difference data and a target difference type corresponding to the target difference data, and the target difference data is the at least data in a difference data;

The processing module is further configured to generate a target test case according to the target difference data, the target difference type and the latest test case.
A processing device for a test case, characterized in that it includes:

The receiving module is configured to receive a first message sent by the server, where the first message includes at least one difference data and a difference type corresponding to each difference data, and the difference data is the difference between the test case to be saved and the latest test case. Difference data, the test case to be saved and the latest test case are obtained by modifying the basic test case;

a display module for displaying the difference data and the difference type;

a processing module, configured to determine target difference data and a target difference type corresponding to the target difference data, where the target difference data is data in the at least one difference data;

A sending module, configured to send a second message to the server, where the second message includes the target difference data and the target difference type, and the second message is used to instruct the server according to the target difference data , the target difference type and the latest test case to generate a target test case.
A server, characterized in that it includes:

transceiver;

processor;

memory; and

Computer program;

wherein the computer program is stored in the memory and configured to be executed by the processor, the computer program comprising instructions for performing the method of any of claims 1-6.
A terminal device, characterized in that it includes:

transceiver;

monitor;

processor;

memory; and

Computer program;

wherein the computer program is stored in the memory and configured to be executed by the processor, the computer program comprising instructions for performing the method of any of claims 7-11.
A computer-readable storage medium, characterized in that the computer-readable storage medium stores a computer program, and the computer program causes an electronic device to execute the method of any one of claims 1-11.
A computer program product, comprising a computer program, characterized in that, when the computer program is executed by a processor, the method of any one of claims 1-11 is implemented.