CN112383434A

CN112383434A - Interface simulation method and device for network request, electronic equipment and storage medium

Info

Publication number: CN112383434A
Application number: CN202011287863.3A
Authority: CN
Inventors: 沈凌潇; 陈奕文
Original assignee: Guangdong Oppo Mobile Telecommunications Corp Ltd
Current assignee: Guangdong Oppo Mobile Telecommunications Corp Ltd
Priority date: 2020-11-17
Filing date: 2020-11-17
Publication date: 2021-02-19
Anticipated expiration: 2040-11-17
Also published as: CN112383434B

Abstract

The application discloses an interface simulation method, an interface simulation device, electronic equipment and a computer-readable storage medium for network requests. The interface simulation method comprises the following steps: and constructing a calling package of the network request, acquiring the network request through the calling package, determining a matched Mock rule according to the network request, determining a preset return body according to the Mock rule and returning the preset return body. Therefore, the Mock to the network request is realized, the stability of data returned by the network request is ensured, and the stability of the tested system is improved.

Description

Interface simulation method and device for network request, electronic equipment and storage medium

Technical Field

The present application relates to computer technologies, and in particular, to an interface simulation method for a network request, an interface simulation apparatus, an electronic device, and a computer-readable storage medium.

Background

In the micro-service architecture, because each service often has many upstream and downstream dependencies, such as providing data or processing data, when testing a service writing unit, in order to ensure the accuracy of the data in the test, Mock can be performed on the HTTP request of the service, thereby ensuring the stability of the data returned by the HTTP request.

However, in the related art, the mock needs to rely on a Servlet (Servlet), the system resource overhead is high, and the mock aspect class needs to be implemented for each interface of the mock by adding annotation, the code amount is large, and in addition, the additionally implemented codes are packed and issued to the system, so that useless codes exist in the whole system, and the risk of system problems is increased. Therefore, how to conveniently and quickly implement Mock of the HTTP request and ensure the stability of the system becomes critical.

Disclosure of Invention

In view of the above, the present application is directed to solving, at least to some extent, one of the problems in the related art. To this end, an object of the present application is to provide an interface simulation method, an interface simulation apparatus, an electronic device, and a computer-readable storage medium for a network request.

The interface simulation method for the network request of the embodiment of the application comprises the following steps:

constructing a calling package of the network request;

obtaining the network request through the calling package;

determining a matched Mock rule according to the network request; and

and determining a preset return body according to the Mock rule and returning the preset return body.

The interface simulation device for network requests according to the embodiment of the present application includes:

a construction module for constructing a call package of the network request;

an obtaining module, configured to obtain the network request through the calling package;

the determining module is used for determining a matched Mock rule according to the network request; and

and the return module determines a preset return body according to the Mock rule and returns the preset return body.

The electronic device of the embodiment of the application comprises a processor, wherein the processor is used for:

constructing a calling package of the network request;

obtaining the network request through the calling package;

determining a matched Mock rule according to the network request; and

The electronic equipment of the embodiment of the application comprises one or more processors and a memory; and

one or more programs, wherein the one or more programs are stored in the memory and executed by the one or more processors, the programs comprising instructions for performing the interface simulation method. The interface simulation method comprises the following steps: constructing a calling package of the network request, acquiring the network request through the calling package, and determining a matched Mock rule according to the network request; and determining a preset return body according to the Mock rule and returning the preset return body.

The computer-readable storage medium of embodiments of the present application includes a computer program that, when executed by one or more processors, causes the processors to perform the interface simulation method. The interface simulation method comprises the following steps: constructing a calling package of the network request, acquiring the network request through the calling package, and determining a matched Mock rule according to the network request; and determining a preset return body according to the Mock rule and returning the preset return body.

In the interface simulation method, the interface simulation apparatus, the electronic device, and the computer-readable storage medium for network requests according to the embodiments of the present application, a call package is constructed according to a network request, and then the network request of a system under test is obtained by the call package, and then a corresponding Mock rule is matched according to the network request to implement Mock for the network request, so that data corresponding to the network request is returned. Therefore, the Mock of the network request is realized, the stability of data returned by the network request is ensured, in addition, the network request of the tested system is obtained by calling and packaging, the code invasion of the tested system is avoided, and the stability of the tested system is improved.

Drawings

The foregoing and/or additional aspects and advantages of the present application will become apparent and readily appreciated from the following description of the embodiments, taken in conjunction with the accompanying drawings of which:

FIG. 1 is a flow chart illustrating a method for interface emulation of network requests according to some embodiments of the present disclosure.

FIG. 2 is a block diagram of an interface emulation network-requested device according to some embodiments of the present application.

FIG. 3 is a block diagram of an electronic device according to some embodiments of the present application.

FIG. 4 is a block diagram of an electronic device according to some embodiments of the present application.

FIG. 5 is a schematic diagram of a connection between a processor and a computer-readable storage medium according to some embodiments of the present application.

FIG. 6 is a schematic diagram of a scenario of an interface simulation method according to some embodiments of the present application.

FIG. 7 is a schematic diagram of another scenario of an interface simulation method according to some embodiments of the present application.

FIG. 8 is a further schematic flow chart diagram of an interface simulation method according to some embodiments of the present application.

Description of the main element symbols:

electronic device 1, interface simulation means 10, building module 11, obtaining module 12, determining module 13, returning module 14, processor 20, memory 30, program 32, computer readable storage medium 40, computer program 42.

Detailed Description

Reference will now be made in detail to embodiments of the present application, examples of which are illustrated in the accompanying drawings, wherein like or similar reference numerals refer to the same or similar elements or elements having the same or similar function throughout. The embodiments described below with reference to the accompanying drawings are illustrative and are only for the purpose of explaining the present application and are not to be construed as limiting the present application.

In the description of the present application, it is to be understood that the terms "first", "second" are used for descriptive purposes only and are not to be construed as indicating or implying relative importance or implying any number of technical features indicated. Thus, features defined as "first", "second", may explicitly or implicitly include one or more of the described features. In the description of the present application, "a plurality" means two or more unless specifically defined otherwise.

In the description of the present application, it is to be noted that, unless otherwise explicitly specified or limited, the terms "mounted," "connected," and "connected" are to be construed broadly, e.g., as meaning either a fixed connection, a removable connection, or an integral connection; may be mechanically connected, may be electrically connected or may be in communication with each other; either directly or indirectly through intervening media, either internally or in any other relationship. The specific meaning of the above terms in the present application can be understood by those of ordinary skill in the art as appropriate.

The following disclosure provides many different embodiments or examples for implementing different features of the application. In order to simplify the disclosure of the present application, specific example components and arrangements are described below. Of course, they are merely examples and are not intended to limit the present application. Moreover, the present application may repeat reference numerals and/or letters in the various examples, such repetition is for the purpose of simplicity and clarity and does not in itself dictate a relationship between the various embodiments and/or configurations discussed.

The whole system of the microservice architecture is usually dispersed into a plurality of service systems, each service system respectively realizes corresponding functions, and the service systems generally interact with each other through a HyperText Transfer Protocol (HTTP) or a remote invocation Protocol such as Dubbo.

Unit testing is an effective means of ensuring code quality. It finds possible problems in the code as early as possible and repairs them by testing local methods, classes, etc. at the encoding stage.

When a service system writing unit is tested, often a service is in a scene of interacting with other service systems through network requests such as HTTP or Dubbo, and the accuracy of data cannot be guaranteed in the testing process, so that the testing of the service system fails frequently due to external factors. Therefore, in order to solve this problem, the unit test may perform Mock on HTTP requests outside the service system, and guarantee the stability of the data returned by these data requests.

As will be understood by those skilled in the relevant art, mock is a method for creating a virtual object to simulate the behavior of an object for some objects that are not easily constructed/obtained during a test process.

However, in the related art, the Mock scheme adopted for Mock of the HTTP request depends on a three-party Spring Framework, and the Mock may not be available along with the upgrade of the Framework version. In the aspect of scheme performance, Mock needs to rely on a Servlet (Servlet), engineering needs to be started every time the Mock is used, system resource overhead is high, and a Mock aspect class needs to be realized for each interface of Mock by adding annotation, so that code quantity is large. In addition, the additionally realized codes are packed and issued to the micro-service architecture system, so that useless codes exist in the whole system, and the risk of system problems is increased. Therefore, when testing the system, how to conveniently and quickly implement HTTP request for Mock, and ensuring the stability of the service system becomes a key.

In view of the above, referring to fig. 1, an embodiment of the present invention provides an interface simulation method for a network request, where the interface simulation method includes:

s11: constructing a calling package of the network request;

s12: obtaining a network request by calling encapsulation;

s13: determining a matched Mock rule according to the network request; and

s14: and determining a preset return body according to the Mock rule and returning the preset return body.

Referring further to fig. 2, the present embodiment provides a network requested interface simulation apparatus 10. The interface simulation apparatus 10 includes a construction module 11, an acquisition module 12, a determination module 13, and a return module 14.

Step S11 may be implemented by the construction module 11, step S12 may be implemented by the acquisition module 12, step S13 may be implemented by the determination module 13, and step S14 may be implemented by the return module 14.

Alternatively, the building module 11 may be used to build a call package for the network request.

The fetch module 12 may be used to fetch network requests by calling encapsulation.

The determination module 13 may be configured to determine a matching Mock rule according to a network request.

The return module 14 may determine the preset return volume according to the Mock rule and return the preset return volume.

Referring to fig. 3, an embodiment of the present application provides an electronic device 1, and the interface simulation method of the present application can be completed by the electronic device 1. The electronic device 1 comprises a processor 20.

The processor 20 may be configured to build a call encapsulation for the network request and to obtain the network request through the call encapsulation. The processor 20 may also be configured to determine a matched Mock rule according to the network request, determine a preset returning body according to the Mock rule, and return to the preset returning body.

Referring to fig. 4, the present application provides an electronic device 1 comprising one or more processors 20, a memory 30; and one or more programs 32, wherein the one or more programs 32 are stored in the memory 30 and executed by the one or more processors 20, the programs 32 being executed by the processors 20 to execute instructions of the interface simulation method.

Referring to fig. 5, the present application provides one or more non-transitory computer-readable storage media 40 containing a computer program 42 that, when executed by one or more processors 20, causes the processors 20 to perform an interface simulation method.

In the interface simulation method for network requests, the interface simulation apparatus 10, the electronic device 1, and the computer-readable storage medium 40 according to the embodiments, the network request of the system under test is obtained by establishing the call package of the network request, and matching the corresponding Mock rule according to the network request, and finally realizing the Mock of the network request by the Mock rule, so as to determine the corresponding preset return body, thereby realizing the Mock of the network request and ensuring the stability of the data returned by the network request. In addition, the network request of the system to be tested is obtained by calling the package, so that code intrusion on the system to be tested is avoided, and the stability of the system to be tested is improved.

In some embodiments, the electronic device 1 may be a mobile phone, a computer, a smart wearable device (smart watch, smart bracelet, smart helmet, smart glasses, etc.), a virtual reality device, or a head display device.

In the present embodiment, the electronic device 1 is a computer, that is, the interface simulation method and the interface simulation apparatus 10 are applied to, but not limited to, computers. The interface simulation apparatus 10 may be hardware or software preinstalled in a computer, and may perform the interface simulation method when the computer is started. For example, the interface simulation apparatus 10 may be a part of the operating system or the underlying software code segment of the computer.

In some embodiments, the interface simulation apparatus 10 may be part of the electronic device 1. Alternatively, the electronic device 1 comprises interface simulation means 10.

In some embodiments, the interface simulation apparatus 10 may be a discrete component assembled in such a way as to have the aforementioned functions, or a chip having the aforementioned functions in the form of an integrated circuit, or a computer software code segment that causes a computer to have the aforementioned functions when run on the computer.

In some embodiments, interface simulation apparatus 10 may be a stand-alone or add-on peripheral component to a computer or computer system as hardware. The interface simulation apparatus 10 may also be integrated into a computer or computer system, for example, the interface simulation apparatus 10 may be integrated into the processor 20 when the interface simulation apparatus 10 is part of the electronic device 1.

In some embodiments where the interface emulation device 10 is part of the electronic device 1, as software, the code segments corresponding to the interface emulation device 10 can be stored in the memory 30 and executed by the processor 20 to implement the aforementioned functions. Alternatively, interface simulation apparatus 10 includes one or more of programs 32 as described above, and alternatively, one or more of programs 32 as described above includes interface simulation apparatus 10.

In some embodiments, the computer-readable storage medium 40 may be a storage medium built in the electronic device 1, for example, the memory 30, or a storage medium that can be plugged into the electronic device 1, for example, an SD card.

It should be noted that, the electronic device may store a system under test, and the interface simulation method of the present application is used for unit testing of the system under test. The tested system can include but is not limited to a browser, a short video, a magazine and other server programs, that is, when the browser, the short video, the magazine and other server programs perform unit testing on the tested system, the interface simulation method of the present application can be used to implement Mock on the network request of the browser, the short video, the magazine and other server programs, and ensure the stability of the returned data of the network request.

It should be further noted that the electronic device 1 further includes a network interface, where the network interface is used for implementing remote interaction with other services, and the network interface is used for sending a network request to the other services and receiving data corresponding to the network request. Or receiving network requests or data sent by other services, etc.

Network requests include, but are not limited to, HTTP requests or Dubbo requests, etc. Dubbo refers to a lightweight remote invocation protocol developed by arizba. An HTTP request refers to a request message from a client to a server. HTTP requests include Location (Location) requests, Header (Header) requests, and Uniform Resource Locator (URL) requests. The URL is an internal character string used to describe information resources on the Internet, including a file, an address of a server, a directory, and the like.

In the present application, the network request is an HTTP request, that is, the network request sent by the system under test is an HTTP request but is not limited to the HTTP request.

Referring to fig. 6, specifically, the electronic device 1 includes a unit testing module, and the unit testing module is used to implement unit testing of a system under test, where the system under test includes, but is not limited to, a browser, a short video, a magazine, and other server programs. The unit test module includes a call encapsulation Channel and a thread local variable ThreadLocal.

As will be understood by those skilled in the relevant art, packaging a Channel refers to packaging something together and then presenting it in a new, complete form; the process of hiding attributes, methods or implementation details is called encapsulation. In the present application, the package calling refers to a package generated by implementing a network request to call the function for packaging.

It should be noted that, since the calling package is a package for implementing the network request calling function, the calling package can avoid the code intrusion of the system under test to the system under test during unit test, and improve the stability of the system under test.

The call encapsulation may be constructed by the processor 20 to obtain network requests for the system under test. Specifically, the call package includes a Mock Interface for Mock, which may be an Application Programming Interface (API), which is also called an Application Programming Interface (API), and is a set of definitions, programs, and protocols, and the communication between computer software can be realized through the Application Programming Interface. And calling and packaging to obtain the HTTP request through an application program interface for Mock in the process of sending the network request to the network interface by the tested system.

Thread local is a storage class inside a thread, and can store data in a specified thread, and after the data is stored, only the specified thread can obtain the stored data. In the present application, the thread local variable may be used to store the HTTP Mock rule and the preset return body.

The HTTP Mock rule is used for realizing Mock of the HTTP request. The HTTP Mock rule can comprise a plurality of HTTP Mock rules, each HTTP Mock rule corresponds to one HTTP request, and therefore, the Mock of a plurality of HTTP requests can be realized.

The preset return body refers to data returned after Mock is performed on the HTTP request. The preset playback body comprises normal return data or an abnormal state code.

The normal return data may include, but is not limited to, a location parameter, a header parameter, and a uniform resource locator parameter. It is to be understood that the location parameter is responsive to a location request of an HTTP request, the header parameter is responsive to a header parameter request of an HTTP request, and the uniform resource locator parameter is responsive to a uniform resource locator parameter request.

The exception status code may include a plurality of exception status codes, for example, the exception status code may be 403, 404, 500, 503, or the like. Wherein. The exception status code 403 indicates that the HTTP request of the system under test is rejected, i.e., rejected. The exception status code 404 indicates that the requested resource path does not exist. Exception status code 500 indicates an internal error in the server that the request cannot be completed. The exception status code 503 indicates that the service is not available. In the process of performing Mock on the HTTP request according to the HTTP Mock rule, if an abnormality occurs, a corresponding abnormal status code is returned, for example, the HTTP Mock rule refuses to perform Mock on the HTTP request, and then the step may be returned to 403.

Specifically, after the package is called to obtain the HTTP request, the packaged Mock interface is called to inquire the Threadlocal, the HTTP request is matched with the HTTP Mock rule in the Threadlocal, and when the HTTP request is matched with the corresponding HTTP Mock rule, the HTTP request is Mock-up and data are returned according to the HTTP Mock rule. If the Mock is normally finished, normal return data such as the position parameter, the header parameter, the uniform resource locator parameter and the like are returned, and if the Mock is abnormal, the corresponding abnormal state code is returned.

Please refer to fig. 7, it should be noted that, if the HTTP Mock rule matched with the HTTP request is not obtained when the packaged Mock interface is called to query the thread local, the package is called to initiate the HTTP request to the network interface, so as to obtain data from the network interface, thereby completing the actual service process.

In summary, in the interface simulation method, the interface simulation apparatus 10, the electronic device 1, and the non-volatile computer-readable storage medium 40 stored therein, when performing a unit test on a system under test, an HTTP request sent by the system under test to a network interface is intercepted by calling a package, and a corresponding HTTP Mock rule is queried, so that Mock can be performed on the HTTP request according to the HTTP Mock rule, and data in a preset return body is matched according to the HTTP request, so that data expected to be obtained in the unit test is returned, and stability of the unit test is ensured. Moreover, the system to be tested is not invaded, so that the influence on the function of the system to be tested is avoided, and the stability of the system to be tested is improved.

Referring to fig. 8, in some embodiments, S12 further includes the steps of:

s122: sending a test request to a system under test to enable the system under test to generate a network request;

s124: and intercepting a network request generated by the tested system.

Referring further to fig. 2, in some embodiments, steps S122 and S124 may be implemented by the obtaining module 12.

In other words, the obtaining module 12 is configured to send a test request to the system under test to enable the system under test to generate a network request, and the obtaining module 12 may be further configured to intercept the network request generated by the system under test.

In some embodiments, the processor 20 may be configured to send a test request to the system under test to enable the system under test to generate a network request, and the processor 20 may be further configured to intercept the network request generated by the system under test.

Please further refer to fig. 6 or 7, it should be noted that the unit Test module further includes a Test Case (Test Case), where the Test Case refers to a description of a Test task performed on a specific software product, and embodies a Test scheme, a method, a technique, and a policy. In the application, the unit test module sends a test request to the system under test through the test case so that the system under test generates a network request, and receives data returned according to the network request.

It can be understood that, in general, after the network request is generated by the system under test, the network request is sent to the network interface, so that the return data corresponding to the network request can be acquired from the network interface. Therefore, the network request is prevented from being sent to the network interface, so that subsequent Mock of the network request can be realized, data corresponding to the network request is returned, and the network request is intercepted by calling and packaging in the process that the tested system sends the network request to the network interface. Therefore, the decoupling requirements on the network interface are met, the compiling efficiency of the unit test is improved, and the stability of the unit test is ensured. .

The above examples only express several embodiments of the present application, and the description thereof is more specific and detailed, but not construed as limiting the scope of the present application. It should be noted that, for a person skilled in the art, several variations and modifications can be made without departing from the concept of the present application, which falls within the scope of protection of the present application. Therefore, the protection scope of the present patent shall be subject to the appended claims.

Claims

1. A method for interface emulation of a network request, comprising:

constructing a calling package of the network request;

obtaining the network request through the calling package;

determining a matched Mock rule according to the network request; and

2. The interface emulation method of claim 1, wherein the network request comprises an HTTP request, and wherein the HTTP request comprises a location request, a header request, and a uniform resource locator parameter request.

3. The interface emulation method of claim 1, wherein the default return entity comprises normal return data and an exception status code.

4. The interface emulation method of claim 1, wherein said obtaining the network request via the call encapsulation comprises:

sending a test request to a system under test to enable the system under test to generate a network request;

and intercepting the network request generated by the tested system.

5. An interface emulation device for network requests, the interface emulation device comprising:

a construction module for constructing a call package of the network request;

6. An electronic device, comprising a processor configured to:

constructing a calling package of the network request;

obtaining the network request through the calling package;

determining a matched Mock rule according to the network request; and

7. The electronic device of claim 7, comprising a thread local variable to store a Mock rule and a preset return volume.

8. The electronic device of claim 7, further comprising a test case, wherein the test case is configured to send a test request to a system under test to enable the system under test to send a network request.

9. An electronic device comprising one or more processors, memory; and

one or more programs, wherein the one or more programs are stored in the memory and executed by the one or more processors, the programs comprising instructions for performing the network requested interface emulation method of any of claims 1-4.

10. A non-transitory computer-readable storage medium containing a computer program, which when executed by one or more processors causes the processors to perform the network requested interface emulation method of any of claims 1-4.