CN114880209A

CN114880209A - Software testing method, device and storage medium

Info

Publication number: CN114880209A
Application number: CN202210368309.0A
Authority: CN
Inventors: 钟经纬; 王凯
Original assignee: Chenbei Tianjin Technology Co ltd
Current assignee: Chenbei Tianjin Technology Co ltd
Priority date: 2022-04-08
Filing date: 2022-04-08
Publication date: 2022-08-09

Abstract

The embodiment of the disclosure discloses a software testing method, a device and a storage medium, wherein the method comprises the following steps: acquiring a log file of software to be tested, wherein the log file comprises request parameters of flow data of the software to be tested and an original execution result; acquiring a corresponding new execution result based on the request parameter of the flow data; when the data structures of the original execution result and the corresponding new execution result are different, converting the data structure of the result to be converted to be consistent with the data structure of the reference result to obtain an execution result to be compared, wherein when the result to be converted is the new execution result, the reference result is the original execution result; when the result to be converted is the original execution result, the reference result is the new execution result; comparing the reference result with the execution result to be compared to obtain a test result; and outputting the test result. The embodiment of the disclosure can quickly perform software testing through a real-time flow playback function.

Description

Software testing method, device and storage medium

Technical Field

The present disclosure relates to the field of software testing technologies, and in particular, to a software testing method, an apparatus, and a storage medium.

Background

In the scenes of interface migration, application program splitting, application program reconstruction and the like which need to be subjected to software testing, the testing method for manually constructing test data by testing personnel is long in time consumption, and the data meeting the testing of all scenes is difficult to construct, so that the testing effect is influenced.

In the prior art, a method for implementing software testing through a flow playback test platform is proposed, however, when an application program to be tested accesses the flow playback test platform, a configuration center may need to be modified, for example, if the flow playback test platform needs to perform flow playback on data of a Dubbo interface, a registration center (e.g., zookeeper) corresponding to the Dubbo interface needs to be configured, and configuring the registration center not only wastes resources, but also is cumbersome to operate. In addition, when the traffic playback test platform compares the returned results of the application program to be tested, if the data structures of the returned results of the new version and the old version of the application program to be tested are different, the project code and the deployment code also need to be modified, which also causes waste of time resources and human resources. In order to solve the above problems, the present disclosure provides a new traffic playback test platform to enable software testing to be performed quickly through a real-time traffic playback function.

Disclosure of Invention

The embodiment of the disclosure provides a software testing method, a device and a storage medium, in order to quickly perform software testing through a real-time flow playback function.

According to an aspect of an embodiment of the present disclosure, there is provided a software testing method, the method including:

acquiring a log file of software to be tested, wherein the log file comprises a request parameter of flow data of the software to be tested and an original execution result, and the flow data is the flow data in the original version software of the software to be tested;

acquiring a corresponding new execution result based on the request parameter of the flow data, wherein the new execution result is the execution result of the flow data in the version to be tested of the software to be tested;

when the data structures of the original execution result and the corresponding new execution result are different, converting the data structure of the result to be converted to be consistent with the data structure of the reference result to obtain an execution result to be compared;

comparing the reference result with the execution result to be compared to obtain a test result;

outputting the test result;

when the result to be converted is the new execution result, the reference result is the original execution result; and when the result to be converted is the original execution result, the reference result is the new execution result.

In one embodiment of the present disclosure, the method further comprises: receiving a data structure conversion rule pre-configured by the software to be tested;

the converting the data structure of the result to be converted to be consistent with the data structure of the reference result to obtain the result to be compared includes:

dynamically compiling the data structure conversion rule to obtain the data structure conversion tool;

and converting the data structure of the result to be converted according to the data structure conversion rule to obtain the result to be compared.

In another embodiment of the present disclosure, when the reference result and the to-be-compared execution result are in a Json string format, the comparing the reference result and the to-be-compared execution result to obtain a test result includes:

respectively converting the reference result and the to-be-compared execution result into JsonElement elements to obtain a first group of nodes corresponding to the reference result and a second group of nodes corresponding to the to-be-compared execution result;

comparing the first set of nodes and the second set of nodes one by one;

when the first group of nodes and the second group of nodes are completely consistent, determining that the test result is that the test is passed;

when the first group of nodes and the second group of nodes are not completely consistent, determining that the test result is test failure, and determining the highest similarity of the first group of nodes and the second group of nodes.

In another embodiment of the present disclosure, said comparing one by one the first set of nodes and the second set of nodes comprises:

determining a node type of at least one node of the first set of nodes and the second set of nodes;

when the node type of the at least one node is an object or a basic data type or an empty type, comparing whether at least one node in the first group of nodes and the second group of nodes is equal, updating the similarity of the corresponding father node according to the comparison result, and determining the test result according to the similarity of the highest father node;

when the node type of the at least one node is an array, determining the index number and the maximum similarity of the child node which is most similar to the elements in the second array compared with the elements in the first array;

determining the test result according to the maximum similarity;

the first array is a node array in a first group of nodes, and the second array is a node array in a second group of nodes corresponding to the first array.

In another embodiment of the present disclosure, when the node type of the at least one node is an object, after the updating the similarity of the parent node according to the comparison result, the method further includes:

traversing child nodes of the at least one node using a depth traversal algorithm;

performing the operation of determining the node type of the child node of at least one of the first set of nodes and the second set of nodes for the child node of the at least one node.

In another embodiment of the present disclosure, when the original execution result and the to-be-compared execution result are in a text format/a data stream format, the comparing the reference result and the to-be-compared execution result to obtain a test result includes:

comparing the reference result with the execution result to be compared one by one according to the character sequence;

when inconsistent characters/bytes exist, judging that the test result is that the test fails, and outputting inconsistent characters;

and when the characters/bytes of the reference result and the result to be compared are completely the same, judging that the test result is a test pass.

In another embodiment of the present disclosure, when the software to be tested calls the Dubbo interface interaction data, the obtaining the log file of the software to be tested includes:

and receiving the log file sent by a Dubbo filter component introduced by the software to be tested, wherein the Dubbo filter component is a component introduced by the original version software.

In another embodiment of the present disclosure, the obtaining a corresponding new execution result based on the request parameter of the traffic data includes:

acquiring the class name and the method name of the Dubbo interface in the log file;

acquiring domain name information of the Dubbo interface in the version to be tested based on the class name and the method name of the Dubbo interface;

sending a hypertext transfer protocol request message to the version to be tested based on the domain name information, class name and method name of the Dubbo interface;

and receiving a new execution result returned by the http2Dubbo assembly in the version to be tested according to the hypertext transfer protocol request message, wherein the http2Dubbo assembly is an assembly introduced by the version to be tested, and the http2Dubbo assembly is used for analyzing information of a Dubbo interface and calling the Dubbo interface.

According to still another aspect of an embodiment of the present disclosure, there is provided a software testing apparatus, the apparatus including:

the system comprises a first acquisition module, a second acquisition module and a third acquisition module, wherein the first acquisition module is used for acquiring a log file of software to be tested, the log file comprises request parameters of flow data of the software to be tested and an original execution result, and the flow data is the flow data in original version software of the software to be tested;

a second obtaining module, configured to obtain a corresponding new execution result based on the request parameter of the traffic data, where the new execution result is an execution result of the traffic data in the to-be-tested version of the to-be-tested software;

a data structure conversion module for converting the data structure of the result to be converted to be consistent with the data structure of the reference result when the data structures of the original execution result and the corresponding new execution result are different, so as to obtain the result to be compared,

the comparison module is used for comparing the reference result with the execution result to be compared to obtain a test result;

the output module is used for outputting the test result;

In one embodiment of the present disclosure, the apparatus further comprises: the first receiving module is used for receiving a data structure conversion rule configured in advance by the software to be tested;

the data structure conversion module comprises:

the compiling submodule is used for dynamically compiling the data structure conversion rule to obtain the data structure conversion tool;

and the conversion submodule is used for converting the data structure of the result to be converted according to the data structure conversion rule to obtain the result to be compared.

In another embodiment of the disclosure, when the reference result and the to-be-compared execution result are in a Json string format, the comparing module includes:

the first conversion submodule is used for respectively converting the reference result and the to-be-compared execution result into JsonElement elements to obtain a first group of nodes corresponding to the reference result and a second group of nodes corresponding to the to-be-compared execution result;

a first comparison submodule for comparing the first set of nodes and the second set of nodes one by one;

the first determining submodule is used for determining that the test result is that the test is passed when the first group of nodes and the second group of nodes are completely consistent;

and the second determining submodule is used for determining that the test result is test failure and determining the highest similarity of the first group of nodes and the second group of nodes when the first group of nodes and the second group of nodes are not completely consistent.

In yet another embodiment of the present disclosure, the first comparison sub-module includes:

a third determining submodule, configured to determine a node type of at least one node in the first set of nodes and the second set of nodes;

the second comparison submodule is used for comparing whether at least one node in the first group of nodes and the second group of nodes is equal when the node type of the at least one node is an object or a basic data type or a null type, updating the similarity of the corresponding father node according to the comparison result, and determining the test result according to the similarity of the highest father node;

a fourth determining submodule, configured to determine, when the node type of the at least one node is an array, an index number and a maximum similarity of a child node that is most similar to an element in the second array and is compared with an element in the first array;

and a fifth determining submodule, configured to determine the test result according to the maximum similarity, where the first array is a node array in a first group of nodes, and the second array is a node array in a second group of nodes, where the node array corresponds to the first array.

In another embodiment of the present disclosure, when the node type of the at least one node is an object, the apparatus further includes:

a depth traversal module for traversing child nodes of the at least one node using a depth traversal algorithm;

a node type determining module, configured to perform the operation of determining the node type of the child node of at least one node in the first group of nodes and the second group of nodes on the child node of the at least one node.

In another embodiment of the present disclosure, when the reference result and the to-be-compared execution result are in a text format/a data stream format, the comparing module includes:

the third comparison submodule is used for comparing the reference result with the execution result to be compared one by one according to the character sequence;

the first judgment submodule is used for judging that the test result is that the test is not passed and outputting inconsistent characters when inconsistent characters/bytes exist;

and the second judging submodule is used for judging that the test result is a test pass when the characters/bytes of the reference result and the to-be-compared execution result are completely the same.

In another embodiment of the disclosure, when the software to be tested calls a Dubbo interface to interact data, the first obtaining module is specifically configured to receive the log file sent by a Dubbo filter component introduced by the software to be tested, where the Dubbo filter component is a component introduced by the original version software.

In yet another embodiment of the present disclosure, the second obtaining module includes:

the first obtaining submodule is used for obtaining the class name and the device name of the Dubbo interface in the log file;

the second obtaining submodule is used for obtaining the domain name information of the Dubbo interface in the version to be tested based on the class name and the device name of the Dubbo interface;

the sending submodule is used for sending a hypertext transfer protocol request message to the version to be tested based on the domain name information, the class name and the device name of the Dubbo interface;

and the receiving submodule is used for receiving a new execution result returned by the http2Dubbo assembly in the version to be tested according to the hypertext transfer protocol request message, the http2Dubbo assembly is an assembly introduced by the version to be tested, and the http2Dubbo assembly is used for analyzing information of a Dubbo interface and calling the Dubbo interface.

According to still another aspect of the embodiments of the present disclosure, there is provided an electronic apparatus including:

a memory for storing a computer program;

and the processor is used for executing the computer program stored in the memory, and when the computer program is executed, the software testing method is realized.

According to still another aspect of the embodiments of the present disclosure, there is provided a computer-readable storage medium on which a computer program is stored, the computer program, when executed by a processor, implementing the software testing method described above.

According to yet another aspect of embodiments of the present disclosure, there is provided a computer program product comprising computer programs/instructions which, when executed by a processor, implement the above software testing method.

Based on the software testing method, device and storage medium provided by the embodiments of the present disclosure, the flow data and the original execution result in the original version of software are obtained through the flow playback testing platform, then the corresponding new execution result is obtained according to the flow data in the original version of software, and the original execution result and the new execution result are compared, so that the testing result of the software can be obtained. According to the technical scheme, the flow playback test platform is adopted, software test can be rapidly carried out through the real-time flow playback function, when the data structures of the original execution result and the new execution result are different, the data structure conversion tool obtained through dynamic compiling is converted into the execution result with the consistent data structure, developers do not need to modify project codes, the flow playback test platform does not need to be on line again, and the development cost and the maintenance cost of the flow playback test platform are reduced.

The technical solution of the present disclosure is further described in detail by the accompanying drawings and examples.

Drawings

The accompanying drawings, which are incorporated in and constitute a part of this specification, illustrate embodiments of the disclosure and together with the description, serve to explain the principles of the disclosure.

The present disclosure may be more clearly understood from the following detailed description, taken with reference to the accompanying drawings, in which:

FIG. 1 is a flow chart of one embodiment of a software testing method of the present disclosure;

FIG. 2A is a flowchart of a software testing method of the present disclosure comparing an original execution result with a to-be-compared execution result;

FIG. 2B is a schematic diagram of a JsonElement element of the software testing method of the present disclosure into which a Json string is converted;

FIG. 2C is a schematic diagram of a software testing method of the present disclosure showing test results;

FIG. 2D is a flowchart of the software testing method of the present disclosure comparing two groups of nodes one by one;

fig. 3 is a flowchart of flow data playback when the software to be tested calls the Dubbo interface in the software testing method of the present disclosure;

FIG. 4 is a schematic structural diagram of one embodiment of a software testing apparatus of the present disclosure;

FIG. 5 is a schematic structural diagram of a further embodiment of the software testing apparatus of the present disclosure;

FIG. 6 is a schematic structural diagram of a further embodiment of the software testing apparatus of the present disclosure;

fig. 7 is a block diagram of an electronic device according to an exemplary embodiment of the disclosure.

Detailed Description

Various exemplary embodiments of the present disclosure will now be described in detail with reference to the accompanying drawings. It should be noted that: the relative arrangement of the components and steps, the numerical expressions, and numerical values set forth in these embodiments do not limit the scope of the present disclosure unless specifically stated otherwise.

Meanwhile, it should be understood that the sizes of the respective portions shown in the drawings are not drawn in an actual proportional relationship for the convenience of description.

The following description of at least one exemplary embodiment is merely illustrative in nature and is in no way intended to limit the disclosure, its application, or uses.

Techniques, methods, and apparatus known to those of ordinary skill in the relevant art may not be discussed in detail but are intended to be part of the specification where appropriate.

It should be noted that: like reference numbers and letters refer to like items in the following figures, and thus, once an item is defined in one figure, further discussion thereof is not required in subsequent figures.

The disclosed embodiments may be applied to electronic devices such as computer systems/servers, which are operational with numerous other general purpose or special purpose computing system environments or configurations. Examples of well known computing systems, environments, and/or configurations that may be suitable for use with electronic devices, such as computer systems/servers, include, but are not limited to: personal computer systems, server computer systems, thin clients, thick clients, hand-held or laptop devices, microprocessor-based systems, set top boxes, programmable consumer electronics, network pcs, minicomputer systems, mainframe computer systems, distributed cloud computing environments that include any of the above systems, and the like.

The electronic device, such as computer system/server, may be described in the general context of computer system-executable instructions, such as program modules, being executed by a computer system. Generally, program modules may include routines, programs, objects, components, logic, data structures, etc. that perform particular tasks or implement particular abstract data types. The computer system/server may be practiced in distributed cloud computing environments where tasks are performed by remote processing devices that are linked through a communications network. In a distributed cloud computing environment, program modules may be located in both local and remote computer system storage media including memory storage devices.

Summary of the disclosure

The technical scheme provided by the embodiment of the disclosure is applied to a software test scene, and in the scene where software test is required, such as interface migration, application program splitting, application program reconstruction and the like, in order to avoid the problems of huge time consumption and incomplete data required by artificially constructing full-scene test data, a flow playback test platform can be adopted, so that the automatic test of the full scene is realized. In addition, the flow playback test platform provided by the embodiment of the disclosure also solves the problems that the flow data of the Dubbo interface is accessed at low cost, the data structures of the execution result of the original version software and the execution result of the version to be tested are different, and the flow playback test platform performs deduplication processing on elements which have been compared and judged to be equal in the group when the execution result of the original version software and the execution result of the version to be tested are compared, thereby meeting the playback requirement of the test flow and solving the problem of huge repetitive test work during daily interface verification.

Exemplary embodiments

FIG. 1 is a flow chart of one embodiment of a software testing method of the present disclosure; the software testing method can be applied to a traffic playback testing platform (such as a computer system and a server), as shown in fig. 1, and comprises the following steps:

in step 101, a log file of the software to be tested is obtained, where the log file includes a request parameter of flow data of the software to be tested and an original execution result.

In an embodiment, the traffic data is traffic data in the original version of the software to be tested.

In an embodiment, when Software to be tested is usually accessed to a flow playback test platform, the flow playback test platform provides a Software Development Kit (SDK) component for the Software to be tested, and after an original version of the Software to be tested is introduced into the SDK component, a log file can be printed after a flow request sent by the flow playback test platform is received each time. The log file may include information such as request parameters and original execution results of the traffic data.

In an embodiment, to solve the problem of traffic playback of the Dubbo interface, the traffic playback test platform adds a set of Dubbo universal access components to the SDK component provided for the software to be tested, where the Dubbo universal access components include a Dubbo filter component and an http2Dubbo component. Specifically, a Dubbo filter component may be introduced into the original version software of the software to be tested, and an http2Dubbo component may be introduced into the version to be tested, so that the original version software of the software to be tested may obtain the traffic data (including the request parameter and the original execution result) through the introduced Dubbo filter component after receiving the traffic request, and then send the request parameter and the original execution result of the traffic data to the traffic playback test platform.

After software to be tested calling the Dubbo interface introduces the SDK component including the Dubbo universal access component provided by the flow playback test platform, the flow playback test platform does not need to configure a registration center for the Dubbo interface in a configuration center of the flow playback test platform, and resource waste is avoided.

In step 102, a corresponding new execution result is obtained based on the request parameter of the traffic data.

In an embodiment, the new execution result is an execution result of the flow data in the version to be tested of the software to be tested.

In an embodiment, after obtaining the request parameter and the original execution result from the log file, the traffic playback test platform may search information, such as a domain name, a Uniform Resource Locator (URL), and the like, where an interface of the version to be tested of the software to be tested is located in the configuration center, and then call the interface of the version to be tested using the request parameter obtained from the log file, so as to obtain a new execution result.

In an embodiment, after the flow playback test platform obtains a log file of flow data of software to be tested calling a Dubbo interface, information such as a domain name and a class name of the Dubbo interface of a version to be tested can be obtained at a configuration center according to a Dubbo interface class name and a method name in the log file, and then the information is packaged into a hypertext Transfer Protocol (HTTP) request, and the HTTP request is sent to the version to be tested. After receiving the HTTP request, the HTTP2Dubbo component of the version to be tested can analyze the information of the Dubbo interface, reflect and call the Dubbo interface, and then return a new execution result to the flow playback test platform.

In step 103, when the data structures of the original execution result and the corresponding new execution result are different, the data structure of the result to be converted is converted to be consistent with the data structure of the reference result, and the result to be compared is obtained.

In an embodiment, when the result to be converted is the new execution result, the reference result is the original execution result, that is, the data structure of the new execution result may be converted to be consistent with the data structure of the original execution result. In an embodiment, when the result to be converted is the original execution result, the reference result is the new execution result, that is, the data structure of the original execution result may be converted to be consistent with the data structure of the new execution result.

In an embodiment, to implement the technical solution of the embodiment of the present disclosure, the traffic playback test platform may receive a data structure conversion rule configured in advance by the software to be tested. Specifically, the converting the data structure of the result to be converted to be consistent with the data structure of the reference result to obtain the result to be compared includes: dynamically compiling the data structure conversion rule to obtain the data structure conversion tool; and converting the data structure of the result to be converted according to the data structure conversion rule to obtain the result to be compared.

In specific implementation, after a service developer or a tester of software to be tested configures a data structure conversion rule in advance, the data structure conversion rule can be sent to a flow playback test platform when the flow playback test platform is accessed for testing, so that codes can be automatically produced by the flow playback test platform through dynamically compiling the data structure conversion rule when the data structure needs to be converted, and the codes are dynamically compiled into the flow playback test platform to obtain a data structure conversion tool. Therefore, the condition that developers of the flow playback test platform modify codes and redeploy projects is avoided, and the labor cost in communication and project deployment is saved.

In an embodiment, when the original execution result and the new execution result are subjected to data processing, the character string fields which do not need to be compared can be filtered out at the same time, for example, the time stamp information is different in the original execution result and the corresponding new execution result, and the time stamp information does not belong to the content of the software test, so the character string fields which do not need to be compared can be directly filtered out.

In step 104, the reference result and the execution result to be compared are compared to obtain a test result.

In an embodiment, the data types of the reference result and the result to be compared may be in a Json string format, a text format, or a data stream format, and different comparison algorithms may be used for different data types.

In an embodiment, when the reference result and the to-be-compared execution result are in a text format or a data stream format, the specific step of comparing the reference result and the to-be-compared execution result to obtain the test result is as follows: comparing the reference result with the execution result to be compared one by one according to the character sequence; when inconsistent characters/bytes exist, judging that the test result is that the test fails, and outputting inconsistent characters; and when the characters/bytes of the reference result and the result to be compared are completely the same, judging that the test result is a test pass.

After comparing the reference result with the execution result to be compared, inconsistent characters/bytes can be recorded and output for the reference of a tester.

In an embodiment, when the data types of the reference result and the to-be-compared result are in the format of Json string, the reference result and the to-be-compared result can be compared with the embodiment shown in fig. 2A, which will not be described in detail herein.

In step 105, the test result is output.

In an embodiment, when the test result is a test pass, the prompt information of the test pass can be directly output, and when the test result is a test fail, the similarity between the original execution result and the result to be compared and the byte/character and the like causing the test result fail can be further output in addition to the prompt information of the test fail.

In the above steps 101 to 105, the flow data in the original version software is obtained through the flow playback test platform, then the corresponding new execution result is obtained according to the flow data in the original version software, and the original execution result and the new execution result are compared, so that the test result of the software can be obtained. According to the technical scheme, the software test can be rapidly carried out through the real-time flow playback function, when the data structures of the original execution result and the new execution result are different, the data structure conversion tool obtained through dynamic compilation is converted into the execution result with the consistent data structure, a developer does not need to modify the project code, the flow playback test platform does not need to be on-line again, and the development cost and the maintenance cost of the flow playback test platform are reduced.

To better illustrate the software testing scheme of the present disclosure, another example is described below.

Fig. 2A is a flowchart for comparing an original execution result with an execution result to be compared in the software testing method of the present disclosure, fig. 2B is a schematic diagram of a Json element for converting a Json string into the software testing method of the present disclosure, fig. 2C is a schematic diagram for displaying a testing result in the software testing method of the present disclosure, and fig. 2D is a flowchart for comparing two groups of nodes one by one in the software testing method of the present disclosure; in this embodiment, an example of comparing an original execution result and a to-be-compared execution result in a Json string format is shown, and as shown in fig. 2A, the method includes the following steps:

in step 201, the reference result and the to-be-compared execution result are respectively converted into jsoneelement elements, and a first group of nodes corresponding to the reference result and a second group of nodes corresponding to the to-be-compared execution result are obtained.

In one embodiment, the Json strings may be compared using a Diff algorithm. In specific implementation, the original execution result and the to-be-compared execution result may be converted into a jsoneelement element, so as to obtain a first group of nodes corresponding to the original execution result and a second group of nodes corresponding to the to-be-compared execution result. For example, the two Json strings to be compared are as follows:

the Json string 1 and the Json string 2 can be converted into Json element elements, respectively, as shown in fig. 2B, which is a schematic diagram of the conversion of the Json string 1 into the Json element elements. The JsonElement element obtained by converting the Json character string comprises a group of nodes.

In step 202, the first set of nodes and the second set of nodes are compared one by one.

In one embodiment, a depth-first traversal algorithm may be used to traverse the first set of nodes and the second set of nodes and compare the two sets of nodes one by one for being completely equal. The node types of each node may be different, and the node types may be basic data types, null types, arrays, objects, and the like. Different comparison methods can be adopted for different node types, and particularly, two groups of nodes can be compared through the embodiment shown in fig. 2D, including the following steps 211 to 214:

in step 211, a node type of at least one node of the first set of nodes and the second set of nodes is determined.

In an embodiment, the first group of nodes and the second group of nodes are obtained by converting an original execution result and a to-be-compared execution result respectively.

In step 212, when the node type of the at least one node is an object, a basic data type, or a null type, comparing whether at least one node in the first group of nodes and the second group of nodes is equal, updating the similarity of the corresponding parent node according to the comparison result, and determining the test result according to the similarity of the highest parent node.

In one embodiment, the highest parent node may be understood as the root node.

In an embodiment, when the node type is an object or a basic data type or a null type, it may be directly determined whether the two nodes are equal, and the similarity of the parent node is correspondingly updated according to the comparison result, for example, if the two nodes are equal, the similarity of the corresponding parent node may be updated, for example, if the child node 1 in the first group of nodes is equal to the child node 1 in the second group of nodes, the similarity of the parent node corresponding to the child node 1 may be correspondingly updated.

In an embodiment, after the similarity of the parent node is updated according to the comparison result when the node type is the object, the following operations may be further performed: traversing child nodes of the at least one node using a depth traversal algorithm; performing the operation of determining the node type of the child node of at least one of the first set of nodes and the second set of nodes for the child node of the at least one node. That is, when the node type of at least one node is an object, in addition to comparing the node type of at least one node, it is also necessary to traverse and compare whether corresponding child nodes are equal.

In step 213, when the node type of the at least one node is an array, the index number and the maximum similarity of the child node having the most similar element in the second array compared with the element in the first array are determined.

In one embodiment, the first array is a node array in the first set of nodes, and the second array is a node array in the second set of nodes corresponding to the first array.

Because the array contains at least one element, when the node type is the array, many-to-many comparison needs to be performed on a plurality of elements in the array, and if the results are different, there are many possibilities, therefore, when the nodes of the array type are compared, a similarity comparison algorithm can be adopted, and for each array in the array, the most similar result is searched as a test result. As shown in fig. 2C, when comparing the elements in the two arrays, the pair of elements with the highest similarity (the more the number of equal internal fields is, the higher the similarity) may be selected as the test result to be presented, and thus the obtained result is also the most accurate, and in fig. 2C, the pair of elements with the similarity of 67% may be used as the test result to be presented, and the pair of elements with the similarity of 0% may not be presented.

In step 214, the test result is determined according to the maximum similarity.

In step 203, when the first set of nodes and the second set of nodes are completely consistent, the test result is determined to be a test pass.

In an embodiment, when the first group of nodes corresponding to the original execution result and the second group of nodes corresponding to the to-be-compared execution result are completely consistent, it may be determined that the test result passes the test.

In step 204, when the first group of nodes and the second group of nodes are not completely consistent, determining that the test result is a test failure, and determining the highest similarity of the first group of nodes and the second group of nodes.

In one embodiment, after comparing the current element of the first array with the elements in the second array, if not, the information of the most similar elements in all elements in the second array compared with the current element in the first array may be retained, and the retained most similar elements are selected to be displayed as the test result.

In the above steps 201 to 204, the flow playback test platform realizes deep comparison of two Json character strings, and when two node types to be compared are arrays, by retaining information of an element most similar to a current element in the array, it is possible to find 2 most similar elements for displaying a test result when two elements that are not completely identical can be found in the two arrays.

Fig. 3 is a flowchart of flow data playback when the software to be tested calls the Dubbo interface in the software testing method of the present disclosure; the present embodiment exemplifies how to implement playback of traffic data of the Dubbo interface, as shown in fig. 3, including the following steps:

in step 301, the class name and method name of the Dubbo interface in the log file are obtained.

In an embodiment, in order to implement the embodiment of the present disclosure, a Dubbo universal access component needs to be introduced into software to be tested calling interaction data of a Dubbo interface, specifically, a Dubbo filter component is introduced into original version software of the software to be tested, and an http2Dubbo component is introduced into a version to be tested.

In an embodiment, the original version software of the software to be tested may obtain the traffic data (including the request parameters and the original execution results) by the introduced Dubbo filter component after receiving the traffic request, and then send the traffic data to the traffic playback test platform.

In step 302, based on the class name and the method name of the Dubbo interface, the domain name information of the Dubbo interface in the version to be tested is obtained.

In step 303, based on the domain name information, class name, and method name of the Dubbo interface, a hypertext transfer protocol request message is sent to the version to be tested.

In step 304, a new execution result returned by the http2Dubbo component in the version to be tested according to the hypertext transfer protocol request message is received, the http2Dubbo component is a component introduced by the version to be tested, and the http2Dubbo component is used for analyzing information of a Dubbo interface and calling the Dubbo interface.

In steps 301 to 304, after acquiring the log file of the flow data of the software to be tested calling the Dubbo interface, the flow playback test platform may acquire information such as a domain name and a class name of the Dubbo interface of the version to be tested at the configuration center according to the class name and the method name of the Dubbo interface in the log file, and then package the information into an HTTP request, and send the HTTP request to the version to be tested. After receiving the HTTP request, the HTTP2Dubbo component of the version to be tested can analyze the information of the Dubbo interface, reflect and call the Dubbo interface, and then return the new execution result to the flow playback test platform through the HTTP2Dubbo component of the version to be tested.

In the steps 301 to 304, the flow playback test platform provides the Dubbo filter component and the HTTP2Dubbo component for the software to be tested of the Dubbo interface, so that after receiving the flow data sent by the original version software through the Dubbo filter component, a new execution result of the Dubbo interface of the version to be tested is called through an HTTP request, and comparison of the execution results of the two Dubbo interfaces is realized. In the embodiment, the SDK component including the Dubbo universal access component provided by the flow playback test platform is introduced into the software to be tested calling the Dubbo interface, so that the flow data provided by the software to be tested can be quickly obtained without configuring a registration center for the Dubbo interface in the configuration center of the software to be tested, and resource waste is avoided.

Corresponding to the embodiment of the software testing method, the disclosure also provides a corresponding embodiment of the software testing device.

Fig. 4 is a schematic structural diagram of an embodiment of a software testing apparatus according to the present disclosure, which is applied to an electronic device (e.g., a computer system, a server), as shown in fig. 4, the apparatus includes:

the first obtaining module 41 is configured to obtain a log file of the software to be tested, where the log file includes a request parameter of flow data of the software to be tested and an original execution result, and the flow data is flow data in an original version of the software to be tested;

a second obtaining module 42, configured to obtain a corresponding new execution result based on the request parameter of the flow data, where the new execution result is an execution result of the flow data in the to-be-tested version of the to-be-tested software;

a data structure conversion module 43, configured to, when the data structures of the original execution result and the corresponding new execution result are different, convert the data structure of the result to be converted to be consistent with the data structure of the reference result, so as to obtain an execution result to be compared, and when the result to be converted is the new execution result, the reference result is the original execution result; when the result to be converted is the original execution result, the reference result is the new execution result;

a comparison module 44, configured to compare the reference result with the execution result to be compared, so as to obtain a test result;

and the output module 45 is used for outputting the test result.

Fig. 5 is a schematic structural diagram of another embodiment of the software testing apparatus of the present disclosure, as shown in fig. 5, based on the embodiment shown in fig. 4, in an embodiment, the apparatus further includes:

a first receiving module 46, configured to receive a data structure conversion rule preconfigured by the software to be tested;

the data structure conversion module 43 includes:

the compiling submodule 431 is used for dynamically compiling the data structure conversion rule to obtain a data structure conversion tool;

the converting submodule 432 is configured to convert the data structure of the result to be converted according to the data structure conversion rule, so as to obtain the result to be compared.

In an embodiment, when the reference result and the execution result to be compared are in the format of Json character string, the comparing module 44 includes:

the first conversion submodule 441 is configured to convert the reference result and the to-be-compared execution result into jsoneelement elements respectively, so as to obtain a first group of nodes corresponding to the reference result and a second group of nodes corresponding to the to-be-compared execution result;

a first comparison submodule 442 for comparing the first set of nodes and the second set of nodes one by one;

the first determining sub-module 443 is configured to determine that the test result is a test pass when the first group of nodes and the second group of nodes are completely consistent;

the second determining submodule 444 is configured to determine that the test result is a test failure and determine the highest similarity between the first set of nodes and the second set of nodes when the first set of nodes and the second set of nodes are not completely consistent.

In one embodiment, the first comparison sub-module 442 includes:

a third determining submodule 4421 configured to determine a node type of at least one node in the first group of nodes and the second group of nodes;

the second comparing submodule 4422 is configured to, when the node type of the at least one node is an object, a basic data type, or an empty type, compare whether at least one node in the first group of nodes and the second group of nodes is equal, update the similarity of the corresponding parent node according to the comparison result, and determine the test result according to the similarity of the highest parent node;

a fourth determining submodule 4423, configured to determine, when the node type of at least one node is an array, an index number and a maximum similarity of a child node that is most similar to an element in the second array and is compared with the element in the first array;

the fifth determining submodule 4424 is configured to determine a test result according to the maximum similarity, where the first array is a node array in the first group of nodes, and the second array is a node array in the second group of nodes, where the node array corresponds to the first array.

In an embodiment, when the node type of at least one node is an object, the apparatus further includes:

a depth traversal module 47 for traversing child nodes of at least one node using a depth traversal algorithm;

a node type determining module 48, configured to perform an operation of determining a node type of a child node of at least one node of the first group of nodes and the second group of nodes for a child node of the at least one node.

Fig. 6 is a schematic structural diagram of another embodiment of the software testing apparatus of the present disclosure, as shown in fig. 6, on the basis of the embodiments shown in fig. 4 and/or fig. 5, in an embodiment, when the reference result and the result to be compared are in a text format/a data stream format, the comparing module 44 includes:

the third comparison submodule 445 is configured to compare the reference result and the execution result to be compared one by one according to a character sequence;

a first determination submodule 446, configured to determine that the test result is a test failure when there is an inconsistent character/byte, and output an inconsistent character;

the second determining submodule 447 is configured to determine that the test result is a test pass when the reference result and the character/byte of the result to be executed are completely the same.

In an embodiment, when the software to be tested calls the Dubbo interface interaction data, the first obtaining module 41 is specifically configured to receive a log file sent by a Dubbo filter component introduced by the software to be tested, where the Dubbo filter component is a component introduced by the original version of software.

In one embodiment, the second obtaining module 42 includes:

the first obtaining submodule 421 is configured to obtain a class name and a device name of a Dubbo interface in a log file;

the second obtaining sub-module 422 is configured to obtain domain name information of the Dubbo interface in the version to be tested based on the class name and the device name of the Dubbo interface;

the sending submodule 423 is used for sending a hypertext transfer protocol request message to the version to be tested based on the domain name information, the class name and the device name of the Dubbo interface;

the receiving submodule 424 is configured to receive a new execution result returned by the http2Dubbo component in the version to be tested according to the hypertext transfer protocol request message, where the http2Dubbo component is a component introduced by the version to be tested, and the http2Dubbo component is configured to analyze information of the Dubbo interface and call the Dubbo interface.

The implementation process of the functions and actions of each unit in the above device is specifically described in the implementation process of the corresponding step in the above method, and is not described herein again.

For the device embodiments, since they substantially correspond to the method embodiments, reference may be made to the partial description of the method embodiments for relevant points. The above-described embodiments of the apparatus are merely illustrative, and the units described as separate parts may or may not be physically separate, and the parts displayed as units may or may not be physical units, may be located in one place, or may be distributed on a plurality of network units. Some or all of the modules can be selected according to actual needs to achieve the purpose of the disclosed solution. One of ordinary skill in the art can understand and implement it without inventive effort.

An electronic device according to an embodiment of the disclosure is described below with reference to fig. 7, in which an apparatus implementing a method according to an embodiment of the disclosure may be integrated. Fig. 7 is a block diagram of an electronic device provided in an exemplary embodiment of the disclosure, and as shown in fig. 7, the electronic device 7 includes one or more processors 71, one or more memories 72 of a computer-readable storage medium, and a computer program stored on the memories and executable on the processors. The software testing method described above may be implemented when executing the program of the memory 72.

In particular, in practical applications, the electronic device may further include an input device 73, an output device 74, and the like, which are interconnected via a bus system and/or other types of connection mechanisms (not shown). Those skilled in the art will appreciate that the configuration of the electronic device shown in fig. 7 is not intended to be limiting of the electronic device and may include more or fewer components than shown, or certain components, or a different arrangement of components. Wherein:

the processor 71 may be a Central Processing Unit (CPU) or other form of processing unit having data processing capabilities and/or instruction execution capabilities, and may control other components in the electronic device to perform desired functions.

The memory 72 may store one or more computer program products and may include various forms of computer-readable storage media, such as volatile memory and/or non-volatile memory. Volatile memory can include, for example, Random Access Memory (RAM), cache memory (or the like). The non-volatile memory may include, for example, Read Only Memory (ROM), hard disk, flash memory, etc. One or more computer program products may be stored on the computer-readable storage medium and executed by the processor 71 to implement the software testing methods of the various embodiments of the present disclosure above and/or other desired functions.

In one example, the electronic device may further include: an input device 73 and an output device 74, which are interconnected by a bus system and/or other form of connection mechanism (not shown),

further, the input device 73 may include, for example, a keyboard, a mouse, and the like.

The output device 74 may output various information including the determined distance information, direction information, and the like to the outside. The output devices 74 may include, for example, a display, speakers, a printer, and a communication network and remote output devices connected thereto, among others.

Of course, for simplicity, only some of the components of the electronic device 7 relevant to the present disclosure are shown in fig. 7, omitting components such as buses, input/output interfaces, and the like. In addition, the electronic device 7 may comprise any other suitable components, depending on the specific application.

In addition to the above-described methods and apparatus, embodiments of the present disclosure may also be a computer program product comprising computer program instructions that, when executed by a processor, cause the processor to perform the steps in the software testing method according to various embodiments of the present disclosure described in the "exemplary methods" section above of this specification.

The computer program product may write program code for carrying out operations for embodiments of the present disclosure in any combination of one or more programming languages, including an object oriented programming language such as Java, C + + or the like and conventional procedural programming languages, such as the "C" programming language or similar programming languages. The program code may execute entirely on the user's computing device, partly on the user's device, as a stand-alone software package, partly on the user's computing device and partly on a remote computing device, or entirely on the remote computing device or server.

Furthermore, embodiments of the present disclosure may also be a computer-readable storage medium having stored thereon computer program instructions that, when executed by a processor, cause the processor to perform the steps in the software testing method according to various embodiments of the present disclosure described in the "exemplary methods" section above in this specification.

The computer-readable storage medium may take any combination of one or more readable media. The readable medium may be a readable signal medium or a readable storage medium. A readable storage medium may include, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or a combination of any of the foregoing. More specific examples (a non-exhaustive list) of the readable storage medium include: an electrical connection having one or more wires, a portable disk, a hard disk, a Random Access Memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing.

The foregoing describes the general principles of the present disclosure in conjunction with specific embodiments, however, it is noted that the advantages, effects, etc. mentioned in the present disclosure are merely examples and are not limiting, and they should not be considered essential to the various embodiments of the present disclosure. Furthermore, the foregoing disclosure of specific details is for the purpose of illustration and description and is not intended to be limiting, since the disclosure is not intended to be limited to the specific details so described.

In the present specification, the embodiments are described in a progressive manner, each embodiment focuses on differences from other embodiments, and the same or similar parts in the embodiments are referred to each other. For the system embodiment, since it basically corresponds to the method embodiment, the description is relatively simple, and for the relevant points, reference may be made to the partial description of the method embodiment.

Those of ordinary skill in the art will understand that: all or part of the steps for implementing the method embodiments may be implemented by hardware related to program instructions, and the program may be stored in a computer readable storage medium, and when executed, the program performs the steps including the method embodiments; and the aforementioned storage medium includes: various media that can store program codes, such as ROM, RAM, magnetic or optical disks.

The methods and apparatus of the present disclosure may be implemented in a number of ways. For example, the methods and apparatus of the present disclosure may be implemented by software, hardware, firmware, or any combination of software, hardware, and firmware. The above-described order for the steps of the method is for illustration only, and the steps of the method of the present disclosure are not limited to the order specifically described above unless specifically stated otherwise. Further, in some embodiments, the present disclosure may also be embodied as programs recorded in a recording medium, the programs including machine-readable instructions for implementing the methods according to the present disclosure. Thus, the present disclosure also covers a recording medium storing a program for executing the method according to the present disclosure.

The description of the present disclosure has been presented for purposes of illustration and description, and is not intended to be exhaustive or limited to the disclosure in the form disclosed. Many modifications and variations will be apparent to practitioners skilled in this art. The embodiment was chosen and described in order to best explain the principles of the disclosure and the practical application, and to enable others of ordinary skill in the art to understand the disclosure for various embodiments with various modifications as are suited to the particular use contemplated.

Claims

1. A method for testing software, the method comprising:

outputting the test result;

2. The method of claim 1, further comprising: receiving a data structure conversion rule pre-configured by the software to be tested;

3. The method of claim 1, wherein when the reference result and the to-be-compared result are in a Json string format, the comparing the reference result and the to-be-compared result to obtain a test result comprises:

comparing the first set of nodes and the second set of nodes one by one;

4. The method of claim 3, wherein comparing the first set of nodes and the second set of nodes one by one comprises:

determining the test result according to the maximum similarity;

5. The method according to claim 4, wherein after updating the similarity of the parent node according to the comparison result when the node type of the at least one node is the object, the method further comprises:

6. The method of claim 1, wherein when the original execution result and the to-be-compared execution result are in a text format/a data stream format, the comparing the reference result and the to-be-compared execution result to obtain a test result comprises:

7. The method of claim 1, wherein when the software to be tested calls a Dubbo interface interaction data, the obtaining of the log file of the software to be tested comprises:

8. The method according to claim 7, wherein the obtaining of the corresponding new execution result based on the request parameter of the traffic data comprises:

9. A software testing apparatus, characterized in that the apparatus comprises:

the data structure conversion module is used for converting the data structure of the result to be converted to be consistent with the data structure of the reference result when the data structures of the original execution result and the corresponding new execution result are different, so as to obtain the execution result to be compared;

the output module is used for outputting the test result;

10. A computer readable storage medium having computer instructions stored thereon, wherein the computer instructions, when executed by a processor, implement the method of any of claims 1-8.