CN118760598A - A low-code interface automated testing method, device, medium and product - Google Patents

Abstract

The present invention discloses a low-code interface automation test method, device, medium and product, which relates to the field of interface testing. The method includes: when in a single interface test environment, determining the address of the corresponding interface under test according to interface request information and obtaining the response result of the interface under test; verifying the response result and extracting the preset content of the response result after the verification is passed to obtain the preset content variable; the preset content variable is used for the next interface under test to call during the test; the interface request information and the corresponding interface under test and the response result are stored as an interface case in an interface case library; when in a batch test environment, importing case files of various formats into the interface case library to obtain multiple interface cases; constructing an interface automation test task based on the interface case library; executing the interface automation test task, and generating a test report. The present invention improves the efficiency and accuracy of interface testing.

Description

A low-code interface automated testing method, device, medium and product

Technical Field

The present invention relates to the field of interface testing, and in particular to a low-code interface automation testing method, device, medium and product.

Background Art

At present, the pace of business iteration is getting faster and faster, projects are becoming more and more complex, systems are becoming larger and larger, and interface testing is used more and more frequently. However, testers have different levels of mastery of interfaces and codes, which may affect the accuracy and efficiency of interface testing.

Summary of the invention

The purpose of the present invention is to provide a low-code interface automation testing method, device, medium and product to realize low-code and automated interface testing, thereby improving interface testing efficiency and accuracy.

To achieve the above object, the present invention provides the following solutions:

In a first aspect, the present invention provides a low-code interface automation testing method, comprising:

When in a single-interface test environment, determine the address of the corresponding interface under test and obtain the response result of the interface under test according to the interface request information;

Verify the response result, and extract preset content from the response result after the verification is passed to obtain preset content variables; the preset content variables are used for the next tested interface to call during the test;

The interface request information, the tested interface corresponding to the interface request information, and the response result are stored as an interface use case in an interface use case library;

When in a batch test environment, import the use case files in the postman format, excel format, swagger format, and chrome debugging tool copy format into the interface use case library to obtain multiple interface use cases;

Based on the interface use case library, an interface automation test task is constructed; the interface automation test task includes at least one interface use case;

Execute the interface automation test task and generate a test report.

In a second aspect, the present invention provides a computer device comprising: a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the computer program to implement the low-code interface automation testing method.

In a third aspect, the present invention provides a computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements the low-code interface automation testing method.

In a fourth aspect, the present invention provides a computer program product, including a computer program, which implements the low-code interface automation testing method when executed by a processor.

According to the specific embodiments provided by the present invention, the present invention discloses the following technical effects:

In a single interface test environment, the present invention determines the address of the corresponding tested interface according to the interface request information and obtains the response result of the tested interface. After verifying and extracting the response result, a preset content variable is obtained, which can be used for the next tested interface to call during testing; it should be noted that by setting the preset content variable, it can be directly called during the next interface test, reducing the amount of code used and realizing low-code processing. Then the interface request information and the corresponding tested interface and response result are stored in the interface case library as an interface use case. When in a batch test environment, the use case files in the postman format, excel format, swagger format, and chrome debugging tool copy format are imported into the interface case library to obtain multiple interface use cases; it should be noted that by receiving files in different formats and directly converting them, the use of code is also reduced, realizing low-code processing. Finally, an interface automation test task is constructed based on the interface case library, and a test report is executed and generated. There is no need for manual participation in code writing throughout the process, which improves the accuracy and efficiency of interface testing.

In summary, the present invention solves the time cost of learning codes for interface business testing, and the problems caused by reusing interface use cases used in routine testing tasks, thereby improving work efficiency and use case coverage, and can bring efficient interface monitoring and interface management to the project.

BRIEF DESCRIPTION OF THE DRAWINGS

In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the drawings required for use in the embodiments will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present invention. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying creative labor.

Figure 1 is a flow chart of the low-code interface automation testing method of the present invention.

DETAILED DESCRIPTION

The following will be combined with the drawings in the embodiments of the present invention to clearly and completely describe the technical solutions in the embodiments of the present invention. Obviously, the described embodiments are only part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without creative work are within the scope of protection of the present invention.

The purpose of the present invention is to provide a low-code interface automation testing method, device, medium and product, which can perform single interface testing and use external existing use cases to quickly generate interface automation use cases.

In order to make the above-mentioned objects, features and advantages of the present invention more obvious and easy to understand, the present invention is further described in detail below with reference to the accompanying drawings and specific embodiments.

Example 1

As shown in FIG1 , the present invention provides a low-code interface automation testing method, comprising:

When performing interface automation testing, users need to log in to the test platform first and enter the interface tool page; on the interface tool page, they can select the test environment: single interface test, batch import test.

Step 100, when in a single-interface test environment, determine the address of the corresponding interface under test according to the interface request information and obtain the response result of the interface under test.

Specifically, the interface request information is determined according to the interface request document provided by the developer, and the corresponding interface request parameters are input and set on the interface tool page. The interface request information includes the request method, request address, request body and request header information.

The request methods include GET, POST, PUT and DELETE. The request address is the address of the interface under test, such as: https://autotest.***.com/api/admin/addUser. The types of the request body include form-data, x-www-form-urlencoded and json. For example, {"nickname":"**0","username":"**1","password":"**2"}. Examples of request header information include: setting content-type to application/json; charset=UTF-8, etc.

In the interface tool page, after clicking the "Send" button, the corresponding interface address is requested according to the interface request information, and the response result of the tested interface is obtained, and then the front-end page is displayed.

Step 200, verify the response result, and extract preset content from the response result after the verification is passed to obtain preset content variables; the preset content variables are used for the next tested interface to call during testing.

Specifically, verifying the response result includes:

(201) Use regular expressions or JSONPath expressions to extract predetermined information from the response results.

(202) Determine whether the predetermined information satisfies an expected condition; the expected condition is characterized by a comparison mode, and the comparison mode includes including, not including, equal, not equal, greater than, and less than.

(203) If the predetermined information meets the expected conditions, it indicates that the verification is passed; if the predetermined information does not meet the expected conditions, it indicates that the verification is not passed.

For example, the response content is ${RESPONSE}, the extraction value expression (regular expression) is ["message(.*?)"], the comparison mode is inclusion, and the expected value is "New user added successfully"; if ["message":"New user added successfully"] is obtained after parsing, it means that the expected included text is met and the verification passes.

Extracting preset content from the response result specifically includes: extracting the stand-by content from the response result using a regular expression or a JSONPath expression, and storing the stand-by content as a preset content variable.

For example: Use the JSONPath expression [$.data.userId] to extract the response content, and obtain 333 after parsing; store the above result in UserID, and the value can be referenced in the subsequent interface parameter input by specifying the writing method [writing method is ${UserID}]. Before sending the request, ${UserID} will be restored to 333.

After extracting the specified content from the response content of the interface, it can be stored and used by subsequent interfaces; for example, the userId extracted in the above example can be used by subsequent interfaces.

Step 300: store the interface request information, the tested interface corresponding to the interface request information, and the response result as an interface use case in an interface use case library.

In a specific example, when the interface request information, the tested interface corresponding to the interface request information and the response result are stored as an interface use case in an interface use case library, the interface use case is named, and the project and module to which it belongs are determined.

Specifically, after the response result is verified and extracted, click the Save button on the interface tool page, a pop-up window will appear, enter the use case name (such as: Modify the main warehouse inventory and virtual inventory_Execution successful), the project (such as: Open Platform) and the module (such as: Open Platform pre) and other information in the pop-up window, click the Save/Update button, the interface request information and the corresponding tested interface and response results will be saved to an interface use case, and automatically aggregated to the test case library. In actual applications, you can also set the key, priority and add notes.

The interface use cases in the automatic use case library can be displayed in the form of an interface use case list, which includes: serial number, use case name, remarks, module name, project name, priority, request method and request header information, etc.

Step 400, when in a batch testing environment, import the use case files in the postman format, excel format, swagger format, and chrome debugging tool copy format into the interface use case library to obtain multiple interface use cases.

Specifically, in the process of batch importing existing interface case files in the test case library to quickly generate interface automation cases, the import types supported are: postman format (usually saved using postman testing), excel format interface case (testers generally write in EXCEL), swagger format (provided by development), chrome debugging tool copy format, etc. These files store interface input parameters in a very regular manner. These format files are read and the corresponding fields are converted into the format required by the interface tool.

Step 500: construct an interface automation test task based on the interface use case library; the interface automation test task includes at least one interface use case.

In an actual application, on the interface test task page, add an interface automation test task TestSuite, enter the necessary information, and create an interface automation task. Then, click the [Add Use Case] button of the task, select the interface in the test case library, and form the use case of the interface automation task.

Step 600, executing the interface automation test task and generating a test report.

In an actual application, clicking the execution button of an interface automated test task will automatically execute all the use cases in the interface task. After the use case execution is completed, a test report will be generated.

Finally, the technology of the present invention that can realize low-code interface automated testing is:

1) In the single interface test, the present invention extracts the response result, and uses the JSONPath expression [$.data.userId] to extract the content 333 of the userId in the response result. It is stored in the variable UserID; if the subsequent interface 2 wants to query the company information of the user, ${UserID} can be used to represent the user ID, and then interface 2 can continue to extract content from the response result of interface 2, and continue to use it for the subsequent interface of interface 2, and so on. In this way, by extracting the specified content from the previous response result and using it for the next interface, a series of interface tests can be achieved, and the user does not need to write code, but only needs to write the extraction expression to complete the interface test.

2) On the server side, each user is assigned a container A for storing variables (stored in the format of key-value pairs) in advance; in the single interface test, after entering the variable name and extracting the expression, click the debug button, and store {UserID:333} in the server-side container A according to 333 extracted by the expression. When ${UserID} is entered in other interfaces, the server will parse the name in ${} to get the UserID; then go to the user's container A to get the value 333 corresponding to the UserID, and then replace ${UserID} with 333. Through the dynamic reference setting of the above variables, there is no need to add additional UserID-related code, which achieves low code.

3) The import types supported in the present invention include: postman format, excel format interface use case, swagger format, chrome debugging tool copy format, etc. These files store interface input parameters in a very regular manner. These format files are read, the corresponding fields are converted into the format required by the interface tool, and stored in the interface use case library. The present invention does not need to write code for each file, but achieves low code through direct conversion.

Example 2

A computer device includes: a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the computer program to implement the low-code interface automation testing method in Example 1.

Example 3

A computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements the low-code interface automation testing method in Example 1.

Example 4

A computer program product includes a computer program, which implements the low-code interface automation testing method in Example 1 when executed by a processor.

Example 5

A computer device, which may be a database. The computer device includes a processor, a memory, an input/output interface (Input/Output, referred to as I/O) and a communication interface. The processor, the memory and the input/output interface are connected via a system bus, and the communication interface is connected to the system bus via the input/output interface. The processor of the computer device is used to provide computing and control capabilities. The memory of the computer device includes a non-volatile storage medium and an internal memory. The non-volatile storage medium stores an operating system, a computer program and a database. The internal memory provides an environment for the operation of the operating system and the computer program in the non-volatile storage medium. The database of the computer device is used to store pending transactions. The input/output interface of the computer device is used to exchange information between the processor and an external device. The communication interface of the computer device is used to communicate with an external terminal through a network connection. When the computer program is executed by the processor, the low-code interface automation testing method in Example 1 is implemented.

It should be noted that the object information (including but not limited to object device information, object personal information, etc.) and data (including but not limited to data used for analysis, stored data, displayed data, etc.) involved in this application are all information and data authorized by the object or fully authorized by all parties, and the collection, use and processing of relevant data must comply with relevant laws, regulations and standards of relevant countries and regions.

Those of ordinary skill in the art can understand that all or part of the processes in the above-mentioned embodiment methods can be completed by instructing the relevant hardware through a computer program, and the computer program can be stored in a non-volatile computer-readable storage medium. When the computer program is executed, it can include the processes of the embodiments of the above-mentioned methods. Among them, any reference to the memory, database or other medium used in the embodiments provided in the present application can include at least one of non-volatile and volatile memory. Non-volatile memory can include read-only memory (ROM), magnetic tape, floppy disk, flash memory, optical memory, high-density embedded non-volatile memory, resistive random access memory (ReRAM), magnetic random access memory (MRAM), ferroelectric random access memory (FRAM), phase change memory (PCM), graphene memory, etc. Volatile memory can include random access memory (RAM) or external cache memory, etc. As an illustration and not limitation, RAM can be in various forms, such as static random access memory (SRAM) or dynamic random access memory (DRAM). The database involved in each embodiment provided in this application may include at least one of a relational database and a non-relational database. Non-relational databases may include distributed databases based on blockchains, etc., but are not limited to this. The processor involved in each embodiment provided in this application may be a general-purpose processor, a central processing unit, a graphics processor, a digital signal processor, a programmable logic device, a data processing logic device based on quantum computing, etc., but are not limited to this.

The technical features of the above embodiments may be arbitrarily combined. To make the description concise, not all possible combinations of the technical features in the above embodiments are described. However, as long as there is no contradiction in the combination of these technical features, they should be considered to be within the scope of this specification.

This article uses specific examples to illustrate the principles and implementation methods of the present invention. The above examples are only used to help understand the method and core ideas of the present invention. At the same time, for those skilled in the art, according to the ideas of the present invention, there will be changes in the specific implementation methods and application scope. In summary, the content of this specification should not be understood as limiting the present invention.

Claims (8)

1. A method for automated testing of a low code interface, the method comprising:

When the single-interface testing environment exists, determining the address of a corresponding tested interface according to the interface request information and acquiring a response result of the tested interface;

verifying the response result, and extracting preset content from the response result after the response result passes the verification to obtain a preset content variable; the preset content variable is used for the next tested interface to be called in the test;

storing the interface request information, the tested interface corresponding to the interface request information and the response result as an interface use case into an interface use case library;

When the interface case library is in a batch test environment, importing use case files in postman format, excel format, swagger format and chrome debugging tool copy format into the interface case library to obtain a plurality of interface cases;

Constructing an interface automatic test task based on the interface use case library; the interface automatic test task at least comprises an interface use case;

And executing the interface automatic test task and generating a test report.

2. The method according to claim 1, wherein the interface request information includes a request method, a request address, a request body, and request header information;

The request method includes GET, POST, PUT and DELETE;

The request address is the address of the tested interface;

the types of the request body include form-data, x-www-form-urlencoded and json.

3. The method for automatically testing the low-code interface according to claim 1, wherein the step of verifying the response result specifically comprises the steps of:

Extracting predetermined information from the response result by using a regular expression or JSONPath expression;

judging whether the preset information meets an expected condition or not; the expected condition is characterized by a comparison pattern comprising include, not include, equal, not equal, greater than, less than;

if the preset information meets the expected condition, the verification is passed; and if the preset information does not meet the expected condition, indicating that the verification is not passed.

4. The method for automatically testing the low-code interface according to claim 1, wherein the extracting the preset content from the response result specifically comprises:

And extracting standby content from the response result by adopting a regular expression or JSONPath expression, and storing the standby content as a preset content variable.

5. The low code interface automated test method of claim 1, further comprising:

And when the interface request information, the tested interface corresponding to the interface request information and the response result are stored as one interface use case to an interface use case library, naming the interface use case, and determining the belonged item and the belonged module.

6. A computer apparatus, comprising: a memory, a processor and a computer program stored on the memory and executable on the processor, characterized in that the processor executes the computer program to implement the low code interface automated test method of any of claims 1-5.

7. A computer readable storage medium having stored thereon a computer program, which when executed by a processor implements the low code interface automated test method of any of claims 1-5.

8. A computer program product comprising a computer program, characterized in that the computer program, when executed by a processor, implements the low code interface automated test method of any of claims 1-5.