CN109189684B

CN109189684B - Python-based automatic interface testing method

Info

Publication number: CN109189684B
Application number: CN201810987431.XA
Authority: CN
Inventors: 王雪涵
Original assignee: Sichuan Changhong Electric Co Ltd
Current assignee: Sichuan Changhong Electric Co Ltd
Priority date: 2018-08-28
Filing date: 2018-08-28
Publication date: 2022-02-22
Anticipated expiration: 2038-08-28
Also published as: CN109189684A

Abstract

The invention discloses a Python-based interface automatic test method which comprises the steps of defining an interface template and a test case template, reading a test case, calling an interface to send a request, analyzing an interface return message and outputting a test report. The Python-based interface automatic testing method provided by the invention follows the basic principle of a testing framework, separates the service logic from the testing script, and separates the testing script from the testing data, so that the testing script can be changed at any time according to the requirements, and the requirements on the coding level of a tester can be greatly reduced.

Description

Python-based automatic interface testing method

Technical Field

The invention relates to the technical field of automated testing, in particular to an automated testing method for an interface based on Python.

Background

The interface test is a test for testing interfaces among components of the system, and is mainly used for detecting interaction points between an external system and the system and between subsystems inside the system. The key point of the test is to check the exchange of data, transfer and control management processes, mutual logic dependency relationship between systems and the like. Most of the current interfaces are used in http protocol, and the basic principle of the test is to simulate a client to send data to a server to obtain corresponding response data, so as to judge whether the interfaces can normally perform data exchange.

The manual test interface is also a test mode, the manual test interface is for each test case, interface parameters need to be modified each time, the expected value of the case needs to be compared one by one after the interface is called, whether the returned value of the interface is consistent with the expected value is judged, if the returned value of the interface is consistent with the expected value, the returned value of the interface passes through the result, reasons need to be found out if the returned value of the interface is inconsistent with the expected value, the result is fed back to developers, corresponding modification is convenient to be carried out, the manual test interface is complex work, especially when the test case reaches a certain order of magnitude, the workload is doubled, the test efficiency is low, and the quality cannot be completely guaranteed. How to improve the test efficiency on the premise of ensuring the test quality, reduce the workload of testers and liberate labor force becomes the problem that the interface test needs to be solved urgently.

Many tools for automated interface testing are available on the market, such as Postman, JMeter, Robot Framework, etc., and various testing tools have different features. Interface testing is carried out on a tool, such as JMeter, which is focused on performance testing, and a test report cannot be generated due to the fact that the tool is a bit large and small in size; postman needs to know and master details of a front-end page to a certain extent through JavaScript script control; the Robot Framework is used as an open source tool, the bottom layer is developed by python, and the Robot Framework has strong library functions to support various test scenes.

Although the interface testing tools have rich choices and basically meet the requirements of simple interface testing, none of the tools can be completely matched to be suitable for each project because different projects have different data processing and business logic processing modes, and the utilization tools need to be familiar with the operation flow to complete various necessary configurations and are not flexible enough. A more flexible interface testing framework needs to be developed by itself to accommodate different project environments.

Disclosure of Invention

The invention aims to overcome the defects in the background technology, provides an automatic interface testing method based on Python, separates service logic from a testing script and separates the testing script from testing data according to the basic principle of a testing framework, can be changed at any time according to requirements, and can greatly reduce the requirements on the coding level of a tester.

In order to achieve the technical effects, the invention adopts the following technical scheme:

the automatic test method of the interface based on Python comprises the following steps:

A. writing a test script by adopting Python, writing a test case on a business layer, and storing the test case by adopting a CSV file format;

B. reading test cases and interface information, and storing the read information as a dictionary format of key value pairs;

C. calling different request functions according to the request method of the tested interface, calling the interface and returning a response message;

D. analyzing the JSON response message, setting assertion, and extracting useful return fields;

E. outputting a test report in a CSV file format;

the Python-based interface automatic test method reads a test case from a CSV file, reads interface information from an Excel file, splices read interface input data into interface parameters, calls an interface, analyzes JSON data returned by the interface, extracts useful fields, and compares the useful fields with an expected return value of the test case, thereby realizing the interface automatic test;

in the Python-based interface automatic test method, a Robot Framework test tool is abandoned, the Python is directly adopted to compile a test script, so that the code amount is greatly reduced, and the reading speed of the program is effectively improved by adopting a CSV file access test case mode, so that the problem of low test efficiency is fundamentally solved, and finally, a simple and clear test report is output in a user-defined mode, so that the test result and the defect positioning are clear at a glance, and the work burden of a tester is reduced.

Further, the step a specifically includes:

A1. defining a test case compiling format, compiling according to columns, and defining a format of interface information;

A2. writing a test script by adopting Python, and writing a test case on a business layer;

A3. and storing the test case in a CSV file format, and storing the interface information in an Excel file format.

Further, the test case writing format is as follows: the first column is the case number, the second column is the case content, the third column is the return value field expected by the case, and the fourth column is the field value corresponding to the return value field.

Further, the interface information at least includes an IP, a domain name, port information, and a request type of the test interface server.

Further, the step B specifically includes:

B1. packaging a function for operating an Excel file for reading test interface information;

B2. installing a function for operating the CSV file to read the test case information;

B3. calling a self-defined function for operating the CSV file format and a self-defined function for operating the Excel file format, and respectively reading a test case and a test interface;

B4. and storing the read interface information and the test case information in a dictionary in a key value pair mode, recording the length of the dictionary, and circularly reading.

Further, the step C specifically includes:

C1. judging the read information of the interface server;

C2. filling the read test data into an interface parameter dictionary to form complete interface parameter information;

C3. and calling the corresponding request function according to the request method of the tested interface and returning the corresponding response message.

Further, the step D specifically stores the JSON packet in a dictionary in the form of a key-value pair and matches the expected return value field name according to the key name.

Further, the test report at least includes the total number of test cases, the test result, the number of failed test cases, the interface return message and the failure reason analysis when used for testing.

Compared with the prior art, the invention has the following beneficial effects:

the automatic test method for the Python-based interface mainly comprises the steps of layering nested JSON according to JSON data returned by the interface, storing useful return value information of each layer into a list, and comparing the useful return values of different layers with all expected values respectively.

Drawings

FIG. 1 is a flow chart of a test using the automated test Framework tool Robot Framework.

Fig. 2 is a test flow chart of the Python-based interface automation test method of the present invention.

Detailed Description

The invention will be further elucidated and described with reference to the embodiments of the invention described hereinafter.

Example (b):

fig. 1 shows a test flow chart of interface test performed by a mainstream automatic test tool Robot Framework at present, the tool is characterized by simple use, very rich library, capability of writing test cases like programming, and support of development system keywords, and the architecture of the tool is a universal automated test Framework (ATDD) for acceptance test and acceptance test driven development, and has an easy-to-use table for organizing test process and test data.

The automatic testing process comprises the following steps: the test cases, interface addresses, and expected return values are first saved in constant form, since these three data must remain unchanged throughout the test. And then, self-defining an interface keyword by utilizing the characteristic of supporting the keywords of the development system, wherein the keyword is a method or a function, and the method comprises four steps of constructing interface parameters, calling an interface, acquiring an interface return value and converting the interface return value into a JSON character string.

When building a parameter, since the test case is also a part of the parameter, the test case needs to be defined as a variable. The user-defined key words have the advantages of simplifying codes and improving the multiplexing rate, and if the interface changes, only the interface constant needs to be modified.

And writing a test case, taking the test case as input data, calling interface keywords, extracting fields needing to be compared from interface return values, comparing the fields with expected return values defined in advance, if the fields are consistent, passing the test case, and otherwise, failing the test case.

And when the execution of the use case is finished, the Robot Framework generates a report in an html format, and the report link is clicked, so that the result of each step of the use case can be checked, and the failure reason can be located.

Practice shows that the Robot Framework is adopted to realize that the automatic test code quantity of the interface is too large, once the test case is changed or the expected value is changed, the test cases need to be modified one by one, the workload is still huge, and the maintenance is difficult; and the use case running time is too long, and although the efficiency is obviously improved compared with the manual test, the ideal effect is still not achieved.

In addition, each test case has a corresponding html test report, but if the number of failed test cases is large, the test report is checked with a large workload, because only which step the code goes to is wrong can be seen from the existing test report, but to exactly find out the root cause of the error, namely which field is not matched with the expected value, the JSON message returned by the case needs to be checked, so that the workload is further increased.

From the above, the current interface testing method mainly has the following problems: the script amount is too large, and the maintenance is difficult; the script has long running time and low efficiency; the test report information quantity is too large, and bug positioning is difficult.

In view of the above technical problems, the present invention discloses a Python-based automated interface testing method, as shown in fig. 2, specifically comprising the following steps:

Because the invention adopts the mode of storing the interface address and the parameters in the Excel file and the test case in the CSV file, the specific formats of the two data files must be defined in advance, and the module is equivalent to a data source in the whole framework. Xls, can be through the configuration file interface, carry on the flexible configuration to IP, domain name, port information, request type (GET, POST) and interface parameter of the interface server to be tested, namely interface template; the defined test case template can flexibly configure a case mode to be run, a case ID list to be run, a return value field name expected by a case and a field value thereof through a testcase-CSV configuration file.

In the specific implementation, a function Excel. py for operating an Excel file can be packaged for reading test interface information, a function CSV. py for operating a CSV file can be packaged for reading test case information, and the two functions can realize read-write operations on any Excel file and CSV file, including reading and writing values of a certain row, a certain column and a certain cell. And storing the read interface information and the test case information in a dictionary in a key value pair mode, recording the length of the dictionary, and circularly reading.

C1. judging the read information of the interface server;

c3 calls the corresponding request function according to the request method of the tested interface and returns the corresponding response message.

Particularly, common HTTP POST and GET request methods are packaged, and free expansion is supported so as to add other methods. The module firstly judges the read information of the interface server, judges which request method needs to be used according to different request types, and because test data is used as input data of an interface and is part of interface parameters, the read test data also needs to be filled in an interface parameter dictionary to form complete interface parameter information, and then calls a corresponding request method to return a corresponding response message.

D. Analyzing the JSON response message, setting assertion, extracting useful return fields, specifically storing the JSON message in a dictionary in a key value pair mode, and matching expected return value field names according to key names;

the method supports JSON format, JSON (JavaScript Object Notation) is a light data exchange format, adopts a text format completely independent of programming language to store and represent data, has a simple and clear hierarchical structure, is easy to read and write by people, is easy to analyze and generate by a machine, can effectively improve the network transmission efficiency, and is an ideal data exchange language.

The returned response message is inevitably provided with JSON data in a nested object format, such as { "ordtotetalPrice": 95, "goods" [ { "shopId": 987654354, "goodsId": 108, "goodsNumber": 1} ] }, at which time the JSON message can be stored in a dictionary in the form of key-value pairs, and the expected return value field names are matched according to the key names, and if the JSON message is matched, the following five conditions can be stored:

the first method comprises the following steps: if the expected return value is null and the actual return value is null, the test is passed;

and the second method comprises the following steps: expecting the return value to be null, actually returning the value to be non-null, stating that the interface returns the field value which should not be returned, the test is not passed;

and the third is that: expecting the return value to be not null, actually returning the value to be null, showing that the interface does not return the field value which should be returned, and the test is not passed;

and fourthly: the expected return value is not null, the actual return value is also not null and is equal to the expected value, and the test is passed;

and a fifth mode: the expected return value is not null, and the actual return value is also not null but not equal to the expected value, which indicates that the interface cannot correctly resolve the case, so that the response is wrong, and the test fails.

E. And outputting the test report in the CSV file format.

And outputting the interface message analyzed in the last step to a test report in a CSV file format, wherein the report comprises the total number of test cases, the test result, the number of failed test cases, the interface return message and failure reason analysis when the test is performed, and the whole process is completed.

The design principle is as follows:

firstly, in the invention, a Robot Framework test tool is abandoned, and a test script is directly written by Python, so that the code amount is greatly reduced.

The code amount is huge because the Robot Framework is used, mainly because the script writing follows the Framework use rule, each case corresponds to one testcase, and when the number of test cases reaches a certain order of magnitude, the code amount is multiplied; and the test case and the interface expected value need to be manually copied from the Excel file and added to the constant file (the constant file is represented by instant), and the preparation work in the early stage is long. Although the bottom layer of the Robot Framework is also supported by Python, the script is directly written by Python, the code logic has no difference, but the code quantity is much more simplified because the direct use of Python does not need to consider a series of bar frame frames and use rules of the Framework, only needs to pay attention to the code logic and the implementation mode, and the later maintenance is simple.

Secondly, the reason that the running time of the Robot Framework test script is too long is obtained through analysis and comparison, not because of the large code amount, but the basic reason is that the whole test efficiency is low because the program takes too long time to read the test case and the interface parameter each time and return the expected value of the parameter.

In the Python-based automatic interface testing method, a CSV file format is adopted to store a test case, and Excel file format is adopted to store interface information; firstly, defining a test case compiling format, compiling according to columns, wherein the first column is a case number, the second column is case content, and then sequentially arranging a return value field expected by the case and a field value corresponding to the return value field; secondly, defining formats of interface information, including IP (Internet protocol), domain name, port information, request type (GET, POST) and the like of an interface server to be tested, calling a self-defined function for operating a CSV (common client) file format and an Excel file format by a program, reading a test case and a test interface, storing the test case and the test interface in a dictionary in a key-value pair mode, recording the length of the dictionary and reading in a circulating mode; and the reading speed of the program is greatly improved by adopting a CSV file access test case mode, so that the problem of low test efficiency is fundamentally solved.

Finally, for the problem of the test report, although the test report in html form is automatically generated by the interface test of the Robot Framework, on the test report, for each use case, the execution result of each step of the test script can be seen, and the test report is more like a breakpoint set by a program. But thousands of test cases, and therefore thousands of test reports, are derived, which greatly increases the workload of the tester, in order to reduce the time for positioning the defects, the automatic test method for the Python-based interface adopts a self-defined test report format, and after one-time test process is finished, a program automatically outputs a complete and detailed test report, the report comprises the total number of test cases, test results, the number of failed test cases, interface return messages and failure reason analysis when in test, which is the result obtained by analyzing the interface return messages, the report is also output in a CSV file format, and the method of the invention outputs a test report in a user-defined mode, so that the test result and the defect positioning are clear, the workload of testers is reduced, and the communication efficiency between the testers and developers is also improved.

It will be understood that the above embodiments are merely exemplary embodiments taken to illustrate the principles of the present invention, which is not limited thereto. It will be apparent to those skilled in the art that various modifications and improvements can be made without departing from the spirit and substance of the invention, and these modifications and improvements are also considered to be within the scope of the invention.

Claims

1. The automatic test method of the interface based on Python is characterized by comprising the following steps:

E. outputting a test report in a CSV file format;

the step A specifically comprises the following steps:

A3. storing a test case in a CSV file format, and storing interface information in an Excel file format;

the step B specifically comprises the following steps:

2. The automated Python-based interface testing method according to claim 1, wherein the test case writing format is: the first column is the case number, the second column is the case content, the third column is the return value field expected by the case, and the fourth column is the field value corresponding to the return value field.

3. The Python-based interface automation test method of claim 1, wherein the interface information includes at least IP, domain name, port information, request type of the test interface server.

4. The automated Python-based interface testing method according to claim 1, wherein the step C specifically comprises:

C1. judging the read information of the interface server;

5. The Python-based interface automation test method of claim 1, wherein the step D specifically adopts the steps of storing JSON messages in a dictionary in a key-value pair form and matching expected return value field names according to key names.

6. The automated Python-based interface testing method according to any one of claims 1 to 5, wherein the test report comprises at least the following data: when the test is used, the total number of the test cases, the test result, the number of the failed test cases, the interface return message and the failure reason are analyzed.