Disclosure of Invention
The technical problem to be solved by the invention is how to solve the problem that the existing method for testing the protocol interface is low in testing efficiency because the format corresponding to the tested protocol interface is complex.
In view of the above technical problem, an embodiment of the present invention provides a method for testing a protocol interface, including:
after request information for testing a preset interface sent by a server is received, acquiring data structure information corresponding to the preset interface from the request information;
converting the data structure information from a current first format into a second format, and generating a first test case for testing the preset interface in the second format according to the data structure information converted into the second format;
converting the first test case into the first format to obtain a second test case, and testing the preset interface through the second test case to obtain a test result;
and generating the test case through the second format more efficiently than the first format.
Optionally, the generating, according to the data structure information converted into the second format, a first test case for testing the preset interface in the second format includes:
and generating a plurality of first test cases in the second format for each test item in the data structure information converted into the second format, and separating different first test cases through preset characters.
Optionally, the converting the first test case into the first format to obtain a second test case, and testing the preset interface through the second test case to obtain a test result includes:
and for each first test case read according to the preset characters, converting the first test case from the second format into the first format to obtain a second test case, sending the second test case to the server, receiving the test result returned by the server, and if the received test result is judged to be abnormal, judging that the preset interface is abnormal.
Optionally, the first format is a protocol buffers format, and the second format is a json format.
In a second aspect, the present embodiment provides an apparatus for testing a protocol interface, including:
the acquisition module is used for acquiring data structure information corresponding to a preset interface from request information after receiving the request information for testing the preset interface, which is sent by a server;
the generating module is used for converting the data structure information from a current first format into a second format, and generating a first test case for testing the preset interface in the second format according to the data structure information converted into the second format;
the test module is used for converting the first test case into the first format to obtain a second test case, and testing the preset interface through the second test case to obtain a test result;
and generating the test case through the second format more efficiently than the first format.
Optionally, the generating module is further configured to generate, for each test item in the data structure information converted into the second format, a plurality of first test cases in the second format, and separate different first test cases by using preset characters.
Optionally, the test module is further configured to, for each first test case read according to the preset character, convert the first test case from the second format to the first format to obtain a second test case, send the second test case to the server, receive the test result returned by the server, and if it is determined that none of the received test results is abnormal, the preset interface is not abnormal.
Optionally, the first format is a protocol buffers format, and the second format is a json format.
In a third aspect, the present embodiment provides an electronic device, including:
at least one processor, at least one memory, a communication interface, and a bus; wherein,
the processor, the memory and the communication interface complete mutual communication through the bus;
the communication interface is used for information transmission between the electronic equipment and the communication equipment of the server;
the memory stores program instructions executable by the processor, the processor calling the program instructions to perform the method of any of the above.
In a fourth aspect, the present embodiments provide a non-transitory computer-readable storage medium storing computer instructions that cause the computer to perform the method of any of the above.
The embodiment of the invention provides a method and a device for testing a protocol interface. And a test case for testing the preset interface can be quickly generated through the second format, and then the test case is sent through the first format for enabling the test case conversion layer to support the communication between the terminal and the server through format conversion, so that the test function is realized. The second format can efficiently generate the test cases, so that efficient testing can be realized by generating the test cases through the second format, and particularly, time and cost can be obviously saved when testing is performed through batch test cases.
Detailed Description
In order to make the objects, technical solutions and advantages of the embodiments of the present invention clearer, the technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the drawings in the embodiments of the present invention, and it is obvious that the described embodiments are some, but not all, embodiments of the present invention. All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present invention.
Fig. 1 is a schematic flowchart of a method for testing a protocol interface according to this embodiment, and referring to fig. 1, the method includes:
101: after request information for testing a preset interface sent by a server is received, acquiring data structure information corresponding to the preset interface from the request information;
102: converting the data structure information from a current first format into a second format, and generating a first test case for testing the preset interface in the second format according to the data structure information converted into the second format;
103: converting the first test case into the first format to obtain a second test case, and testing the preset interface through the second test case to obtain a test result;
and generating the test case through the second format more efficiently than the first format.
The method provided by the embodiment is executed by a testing device (for example, a computer, a mobile phone or a special testing device). The server is a platform for providing a certain service. Generally, a protocol supported by the terminal and the server for communication is complex, and therefore, it is inefficient to generate the test case directly according to a format supported by the protocol. In order to solve the problem, in this embodiment, after receiving request information for testing a preset interface, a terminal converts data structure information corresponding to the interface into a format that is simpler or more familiar to a worker, and then generates a test case, and when the test case is used for testing, the format of the test case is converted, so that the generation efficiency of the test case is improved, and the test efficiency is further improved.
The service end is preset with a test logic for testing a certain service, so that the service end can send request information for testing an interface of the certain service to the terminal according to the test logic. And when the terminal receives the request information, acquiring the data structure information corresponding to the interface from the request information. For example, the interface is used for processing a character representing an animal or an interface for processing a character representing a sex of a person. The second format is generally a more common format than the first format, for example, the first format is a protocol buffers format (pb format), and the second format is a json format, and the test case can be generated more efficiently through the second format. The conversion between the first format and the second format may be implemented by format conversion software, which is not particularly limited in this embodiment. For example, software for realizing the mutual conversion between pb format and json format (a Parse method of protocol buffers is called to convert json into pb format).
In this embodiment, after receiving request information for testing a certain interface, a terminal converts data structure information corresponding to the interface into a second format that is relatively common. And a test case for testing the preset interface can be quickly generated through the second format, and then the test case is sent through the first format for enabling the test case conversion layer to support the communication between the terminal and the server through format conversion, so that the test function is realized. The second format can efficiently generate the test cases, so that efficient testing can be realized by generating the test cases through the second format, and particularly, time and cost can be obviously saved when testing is performed through batch test cases.
Further, on the basis of the foregoing embodiment, the generating, according to the data structure information converted into the second format, the first test case for testing the preset interface in the second format includes:
and generating a plurality of first test cases in the second format for each test item in the data structure information converted into the second format, and separating different first test cases through preset characters.
The preset character may be a delimiter "|", which is not particularly limited in this embodiment. For example, if two test items, i.e., name and gender, are included in the certain data structure information, a plurality of first test cases are generated for the name (for example, the test cases are "zhang" and "123" sent), and a plurality of first test cases are also generated for the gender (for example, the test cases are "male" sent, "female" sent, and "cat" sent), and these test cases are separated by a predetermined character.
The embodiment provides a method for testing a protocol interface, which separates test cases through preset characters when test cases of a certain preset interface are generated in batch, so as to perform format conversion on each test case according to the preset characters.
Further, on the basis of the foregoing embodiment, the converting the first test case into the first format to obtain a second test case, and testing the preset interface through the second test case to obtain a test result includes:
and for each first test case read according to the preset characters, converting the first test case from the second format into the first format to obtain a second test case, sending the second test case to the server, receiving the test result returned by the server, and if the received test result is judged to be abnormal, judging that the preset interface is abnormal.
For example, if a plurality of test cases for testing the preset interface are generated in the json format, the first test case in each json format needs to be converted into the second test case in the pb format according to the preset characters. And sending each second test case to the server side, and returning the test result by the server side. For example, the test results are "the name sent" zhang san "is correct, the name sent" 123 "is incorrect," the sex sent "male" is correct, the sex sent "female" is correct, and the sex sent "cat" is incorrect. And because the judgment of each test case in the test result is correct, the preset interface is proved to be abnormal. And if the test result has an abnormal result, the preset interface has an abnormality.
The embodiment provides a method for testing a protocol interface, which tests the interface through a test case and accurately and quickly judges whether the interface is abnormal or not through a test result.
Further, on the basis of the above embodiment, the first format is a protocol buffers format, and the second format is a json format.
As a specific embodiment, this embodiment provides a method for testing hundreds of gRPC service interfaces, including:
(1) after inquiring about official related documents of the gPRC, finding that a json format which is frequently edited and a protocol buffers data format which is defaulted by the gPRC can be mutually converted, editing a test case by using the json format for the protocol buffers data format provided by a server, then calling a Parse method of the protocol buffers to convert json into a pb format, and further accessing the gPRC service.
(2) And editing the batched json files through a commonly used text document according to a protocol buffers data structure provided by the gPC service, so as to realize the batched test cases.
(3) In the test case text, batch test cases of batch services are realized by adding a separator "|", and the readability of the test cases is increased by adding an annotation line through a # number. For example, for the invitation service, the json format test case produced by the invitation service can be written as:
#invitation
#same org
CreateData|{“visitor：{“visitor_staff”:{“oid：19，”“uid”:1122}},”uuid：“3F2504E0-4F89-11D39AOC-0000000000”，“v”：
#not same org
FetchData|{“visitor：{“visitor_staff”:{“oid：19，”“uid”:1122}},”k：“base_version”:“0”，“k_obj”：
(4) by means of python, the batch test cases of the batch interface are realized by analyzing the service and the test cases in the case text (namely, the test cases are converted into json format).
The embodiment provides a method, and when a set of complete system is faced, the gRPC service is many and each service uses many cases, the method provided by any embodiment can be used for realizing protocol buffers data of the service, and according to a test thought, batch cases of batch interfaces can be completed by editing json text test cases, so that the working efficiency is improved, and the time cost is saved.
Fig. 2 shows a block diagram of an apparatus for testing a protocol interface according to an embodiment of the present invention, and referring to fig. 2, the apparatus for testing a protocol interface according to the embodiment includes an obtaining module 201, a generating module 202, and a testing module 203, where,
an obtaining module 201, configured to obtain, after receiving request information for testing a preset interface sent by a server, data structure information corresponding to the preset interface from the request information;
a generating module 202, configured to convert the data structure information from a current first format into a second format, and generate a first test case for testing the preset interface in the second format according to the data structure information converted into the second format;
the test module 203 is configured to convert the first test case into the first format to obtain a second test case, and test the preset interface through the second test case to obtain a test result;
and generating the test case through the second format more efficiently than the first format.
The apparatus for testing a protocol interface provided in this embodiment is suitable for the method for testing a protocol interface provided in the foregoing embodiment, and details are not described here.
The embodiment of the invention provides a device for testing a protocol interface, and a terminal converts data structure information corresponding to an interface into a second format which is more common after receiving request information for testing the interface. And a test case for testing the preset interface can be quickly generated through the second format, and then the test case is sent through the first format for enabling the test case conversion layer to support the communication between the terminal and the server through format conversion, so that the test function is realized. The second format can efficiently generate the test cases, so that efficient testing can be realized by generating the test cases through the second format, and particularly, time and cost can be obviously saved when testing is performed through batch test cases.
Fig. 3 is a block diagram showing the structure of the electronic apparatus provided in the present embodiment.
Referring to fig. 3, the electronic device includes: a processor (processor)301, a memory (memory)302, a communication Interface (Communications Interface)303, and a bus 304;
wherein,
the processor 301, the memory 302 and the communication interface 303 complete mutual communication through the bus 304;
the communication interface 303 is used for information transmission between the electronic device and the communication device of the server;
the processor 301 is configured to call program instructions in the memory 302 to perform the methods provided by the above-mentioned method embodiments, including: after request information for testing a preset interface sent by a server is received, acquiring data structure information corresponding to the preset interface from the request information; converting the data structure information from a current first format into a second format, and generating a first test case for testing the preset interface in the second format according to the data structure information converted into the second format; converting the first test case into the first format to obtain a second test case, and testing the preset interface through the second test case to obtain a test result; and generating the test case through the second format more efficiently than the first format.
The present embodiments provide a non-transitory computer-readable storage medium storing computer instructions that cause the computer to perform the methods provided by the above method embodiments, for example, including: after request information for testing a preset interface sent by a server is received, acquiring data structure information corresponding to the preset interface from the request information; converting the data structure information from a current first format into a second format, and generating a first test case for testing the preset interface in the second format according to the data structure information converted into the second format; converting the first test case into the first format to obtain a second test case, and testing the preset interface through the second test case to obtain a test result; and generating the test case through the second format more efficiently than the first format.
The present embodiments disclose a computer program product comprising a computer program stored on a non-transitory computer readable storage medium, the computer program comprising program instructions which, when executed by a computer, enable the computer to perform the methods provided by the above-described method embodiments, for example, comprising: after request information for testing a preset interface sent by a server is received, acquiring data structure information corresponding to the preset interface from the request information; converting the data structure information from a current first format into a second format, and generating a first test case for testing the preset interface in the second format according to the data structure information converted into the second format; converting the first test case into the first format to obtain a second test case, and testing the preset interface through the second test case to obtain a test result; and generating the test case through the second format more efficiently than the first format.
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 above-described embodiments of the electronic device and the like are merely illustrative, where 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 also be distributed on multiple network units. Some or all of the modules may be selected according to actual needs to achieve the purpose of the solution of the present embodiment. One of ordinary skill in the art can understand and implement it without inventive effort.
Through the above description of the embodiments, those skilled in the art will clearly understand that each embodiment can be implemented by software plus a necessary general hardware platform, and certainly can also be implemented by hardware. With this understanding in mind, the above-described technical solutions may be embodied in the form of a software product, which can be stored in a computer-readable storage medium such as ROM/RAM, magnetic disk, optical disk, etc., and includes instructions for causing a computer device (which may be a personal computer, a server, or a network device, etc.) to execute the methods described in the embodiments or some parts of the embodiments.
Finally, it should be noted that: the above embodiments are only used for illustrating the technical solutions of the embodiments of the present invention, and are not limited thereto; although embodiments of the present invention have been described in detail with reference to the foregoing embodiments, those skilled in the art will understand that: the technical solutions described in the foregoing embodiments may still be modified, or some or all of the technical features may be equivalently replaced; and the modifications or the substitutions do not make the essence of the corresponding technical solutions depart from the scope of the technical solutions of the embodiments of the present invention.