CN111797020A - Mock data method and device based on dynamic bytecode - Google Patents
Mock data method and device based on dynamic bytecode Download PDFInfo
- Publication number
- CN111797020A CN111797020A CN202010637255.4A CN202010637255A CN111797020A CN 111797020 A CN111797020 A CN 111797020A CN 202010637255 A CN202010637255 A CN 202010637255A CN 111797020 A CN111797020 A CN 111797020A
- Authority
- CN
- China
- Prior art keywords
- mock
- service
- client
- dynamic
- configuration
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/3668—Software testing
- G06F11/3672—Test management
- G06F11/3688—Test management for test execution, e.g. scheduling of test suites
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/70—Software maintenance or management
- G06F8/71—Version control; Configuration management
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/455—Emulation; Interpretation; Software simulation, e.g. virtualisation or emulation of application or operating system execution engines
- G06F9/45504—Abstract machines for programme code execution, e.g. Java virtual machine [JVM], interpreters, emulators
Abstract
The embodiment of the disclosure provides a mock data method and device based on dynamic bytecode. The method comprises the following steps that a Mock configuration end inserts dynamic byte codes into a Mock service of a Mock client and annotates the dynamic byte codes; starting a mock client; the mock client checks whether the mock service has annotation; if yes, the mock service is produced into manually modifiable attributes or methods through dynamic byte codes and displayed to testing personnel; receiving an attribute value manually modified by a tester, and taking the attribute value as a return value of the mock service; and returning the return value to the front end. In this way, in the test process, the server does not need to configure the mock and update to the redis, and notify the web service to restart the mock client, and the client reloads the data in the redis to load a new mock configuration when restarting; the return value can be manually modified in the mock service execution process, so that the test quantity and the test time are greatly reduced.
Description
Technical Field
Embodiments of the present disclosure relate generally to the field of computer technology, and more particularly, to a dynamic bytecode-based mock data method, apparatus, device, and computer-readable storage medium.
Background
mock data (simulation background data) is a technical means for solving closed-loop debugging or testing of front-end development, namely, when the real API of a server is not developed, the front end can complete functional development and testing in advance under the condition of only interface documents. The mock data generally returns a return value such as true or false. In some implementation modes, a mock service capable of being configured through a page is realized by using springboot + wiremock + redis, if dynamic result return needs to be realized, a mock client needs to be stopped to run, a simple web service is started through the springboot to control the mock client, the mock is configured at the server and updated to redis, the web service is notified to restart the mock client, and the client reloads data in the redis to load a new mock configuration when restarting. And the mock configuration needs to be modified and the mock client is restarted every time the return value is modified, so that the test quantity and the test time are greatly increased.
Disclosure of Invention
According to an embodiment of the present disclosure, a mock data scheme based on dynamic bytecode is provided.
In a first aspect of the disclosure, a mock data method based on dynamic bytecode is provided. The method comprises the following steps: inserting dynamic byte codes into the Mock service of the Mock client side by the Mock configuration end and annotating the dynamic byte codes; starting a mock client; the mock client checks whether the mock service has annotation; if yes, the mock service is produced into manually modifiable attributes or methods through dynamic byte codes and displayed to testing personnel; receiving an attribute value manually modified by a tester, and taking the attribute value as a return value of the mock service; and returning the return value to the front end.
As for the above-mentioned aspects and any possible implementation manner, further providing an implementation manner, the inserting and annotating of the dynamic bytecode into the Mock service of the Mock client by the Mock configuration end includes: and the Mock configuration end receives a configuration instruction input by a tester, and inserts a dynamic bytecode into the Mock service of the Mock client according to the configuration instruction and annotates the Mock service.
The above-described aspect and any possible implementation further provide an implementation that the annotation is located in the previous line of the code starting position of the attribute or method that needs to be dynamically modified in the mock service.
The above-mentioned aspect and any possible implementation manner further provide an implementation manner, before the check by the mock client whether the mock service is annotated, further including: and intercepting a request sent by the front end by the Mock client, and starting the corresponding Mock service.
The above-described aspects and any possible implementations further provide an implementation, and the method further includes: and if the mock service has no annotation, executing the appointed corresponding mock service according to the preset mock configuration.
The above-described aspect and any possible implementation manner further provide an implementation manner that the method for producing the mock service into manually modifiable attributes through dynamic bytecode includes: a drop-down box or input box is generated to receive attribute values that are manually modified by a tester.
The above-described aspects and any possible implementations further provide an implementation, and the method further includes: and if the attribute value manually modified by the tester is not received within the preset time, executing the appointed corresponding mock service according to the preset mock configuration.
In a second aspect of the disclosure, a mock data device based on dynamic bytecode is provided. The device includes: the Mock configuration end is used for inserting dynamic byte codes into the Mock service of the Mock client and annotating the dynamic byte codes; starting a mock client; the mock client is used for checking whether the mock service is annotated; if yes, the mock service is produced into manually modifiable attributes or methods through dynamic byte codes and displayed to testing personnel; receiving an attribute value manually modified by a tester, and taking the attribute value as a return value of the mock service; and returning the return value to the front end.
In a third aspect of the disclosure, an electronic device is provided. The electronic device includes: a memory having a computer program stored thereon and a processor implementing the method as described above when executing the program.
In a fourth aspect of the present disclosure, a computer readable storage medium is provided, having stored thereon a computer program, which when executed by a processor, implements a method as in accordance with the first aspect of the present disclosure.
It should be understood that the statements herein reciting aspects are not intended to limit the critical or essential features of the embodiments of the present disclosure, nor are they intended to limit the scope of the present disclosure. Other features of the present disclosure will become apparent from the following description.
Drawings
The above and other features, advantages and aspects of various embodiments of the present disclosure will become more apparent by referring to the following detailed description when taken in conjunction with the accompanying drawings. In the drawings, like or similar reference characters designate like or similar elements, and wherein:
FIG. 1 illustrates a schematic diagram of an exemplary operating environment in which embodiments of the present disclosure can be implemented;
FIG. 2 shows a flow diagram of a dynamic bytecode-based mock data method, according to an embodiment of the disclosure;
FIG. 3 shows a block diagram of a dynamic bytecode-based mock data device, in accordance with embodiments of the present disclosure;
FIG. 4 illustrates a block diagram of an exemplary electronic device capable of implementing embodiments of the present disclosure.
Detailed Description
To make the objects, technical solutions and advantages of the embodiments of the present disclosure more clear, the technical solutions of the embodiments of the present disclosure will be described clearly and completely with reference to the drawings in the embodiments of the present disclosure, and it is obvious that the described embodiments are some, but not all embodiments of the present disclosure. All other embodiments, which can be derived by a person skilled in the art from the embodiments disclosed herein without making any creative effort, shall fall within the protection scope of the present disclosure.
In addition, the term "and/or" herein is only one kind of association relationship describing an associated object, and means that there may be three kinds of relationships, for example, a and/or B, which may mean: a exists alone, A and B exist simultaneously, and B exists alone. In addition, the character "/" herein generally indicates that the former and latter related objects are in an "or" relationship.
Java code is compiled into bytecode and then executed in a JVM, and the bytecode can be interpreted and executed once loaded into a virtual machine. The bytecode file (. class) is a general binary file, which is generated by a Java compiler. If the original byte code file is analyzed by a specific rule, the byte code file is modified or simply redefined, and the code line can be changed.
FIG. 1 illustrates a schematic diagram of an exemplary operating environment 100 in which embodiments of the present disclosure can be implemented. The running environment 100 comprises a mock client 102 and a mock configuration end 104.
In some embodiments, the mock service is divided into a mock client 102 and a mock configuration end 104, wherein the mock client 102 provides the mock service, and the mock configuration end 104 provides the configuration service for the mock service.
In some embodiments, mock configuration end 104 controls mock client 104 through a web service.
Fig. 2 shows a flow diagram of a dynamic bytecode-based mock data method 200 according to an embodiment of the disclosure. Method 200 may be performed interactively by mock configuration end 104 and mock client 102 in fig. 1. As shown in fig. 2, the method comprises the following steps:
at block 210, the mock configuration end 104 receives a configuration instruction input by a tester;
in some embodiments, the configuration instructions are used to configure the mock client 102, including mock configuration of the mock service of the mock client 102 and/or inserting dynamic bytecodes into the mock service of the mock client 102.
In some embodiments, a mock is created, an interface is added to the automated test environment; an interface API is defined, and comprises a request url (item prefix + specific interface name), a request mode, request parameters and a data response.
In some embodiments, the interface is an account opening interface >/trade/open POST// XX account opening interface; the request parameter is msg + sign, msg is the result after json string base64, and sign is a signature; wherein the content of the first and second substances,
data > preceding base64 for msg
"user":"userA",
"account":"userA@163.com",
"order_type":"1"
}。
Json in mock data result that needs to be returned is said
"user":"userA",
"account":"userA@163.com",
"tradeId":"XXXXXXXXXX",
"date": "current date",
"order_type":"1"
}。
wherein the "tradeId": XXXXXXXXXX ", order number, is data requiring mock. In some embodiments, the data that needs mock may also be "tratype": finish/cancel "order status, etc.
In some embodiments, a mock service of the mock client 102 is configured with a mock, and an attribute value of mock dummy data is set, so that the business logic executes a corresponding process. The mock is configured into a data template, and each attribute in the data template consists of 3 parts: attribute name, generation rule, attribute value. The attribute values may be strings, numbers, boolean types, objects, arrays, functions, regular expressions, and the like. The mock service of mock client 102 generates the simulation data from the template.
In some embodiments, dynamic bytecode is inserted into the mock service of the mock client 102 so as to manually modify the attribute values of mock dummy data during the test process, so as to select the flow executed by the business logic.
In some embodiments, a business logic may perform different processes based on the attribute value of an attribute, for example, if the attribute value is true, process a is performed, and if the attribute value is false, process B is performed. In actual development, if the back end interfaces data, namely the attribute values do not exist, the front end can simulate development by mock data. The front end simulates the request to return the corresponding data according to the interface convention, and completes the corresponding interaction.
At block 220, the mock configuration end 104 configures the mock configuration of the mock service of the mock client 102 and/or inserts dynamic bytecode into the mock service of the mock client 102 and annotates the mock configuration according to the configuration instruction;
in some embodiments, the previous line of the code starting position of the dynamically modified attribute or method is required to be annotated in the mock service.
The annotation is to transmit a dynamically generated attribute name or method name to the attribute or method to be dynamically modified, and the mock client 102 can dynamically generate corresponding content based on a dynamic bytecode technology in the starting process.
At block 230, the mock configuration end 104 starts the mock client 102;
in some embodiments, mock client 102 intercepts an Ajax request issued by the front-end, the request being for asking mock client 102 to return simulated response data; and the mock client 102 starts the corresponding mock service according to the Ajax request.
In some embodiments, the mock client 102 intercepts an Ajax request sent by a front end, and determines whether the Ajax request matches a preset URL, where the URL may be a URL string or a URL regular; and if so, starting the corresponding mock service according to the Ajax request.
In some embodiments, the mock client 102 intercepts an Ajax request sent by a front end, and determines whether the Ajax request matches a preset request, the URL may be a URL string or a URL regular, and the type represents the type of the Ajax request to be intercepted; and if the url and the type are matched, starting the corresponding mock service according to the Ajax request.
At block 240, the mock client 102 checks whether the previous line of the starting position of the attribute or method corresponding to the mock service has annotation, which is marked in advance before the attribute or method needing to be manually modified; if no annotation exists, block 250 is performed; if annotations exist, block 260 is performed;
at block 250, the service is executed according to the preset mock configuration, returning a preset return value;
in some embodiments, a function for generating corresponding data is performed, generating simulated data from the data template. When an Ajax request matching the url is intercepted, the function is executed, generating simulation data from the data template and returning as response data, block 280.
At block 260, the property or method is produced as a manually modifiable property or method by dynamic bytecode; and displaying to a tester;
in some embodiments, the corresponding content is dynamically generated based on dynamic bytecode technology and displayed to the tester.
In some embodiments, the content may be a drop-down box or option that includes different attribute values for manual selection by the tester; or may be an input box for the tester to manually input attribute values.
In some embodiments, the mock is configured as a data template, each attribute in the data template consisting of 3 parts: attribute name, generation rule, attribute value. The attribute values may be strings, numbers, boolean types, objects, arrays, functions, regular expressions, and the like. Similarly, the attribute value manually input by the tester also needs to satisfy the mock configuration, that is, the attribute value manually input by the tester also belongs to the range of the attribute value specified in the mock configuration, and if the attribute value is out of the range, the mock client 104 pops up an error prompt to prompt the tester to re-input the attribute value conforming to the range.
In some embodiments, generating mock attributes based on dynamic bytecode includes loading a class file of the java program during runtime of the java program, converting the class file into binary groups; then the mock label part of the binary array is injected with new attributes (new attributes introduced through the annotation); and generating a new calls file (namely a class file capable of dynamically modifying the mock attribute value), and visually displaying the new class file to a tester.
It is first explained that the above method mainly aims at processing object code applied in JVM, JVM is an abbreviation of Java Virtual Machine, JVM is a specification for computing equipment, it is an imaginary computer, and it is realized by simulating various computer functions on an actual computer. After the Java language virtual machine is introduced, the Java language does not need to be recompiled when running on different platforms. The Java language masks information related to a specific platform using a Java virtual machine, so that a Java language compiler can be executed on a variety of platforms without modification by only generating object codes (bytecodes) to be executed on the Java virtual machine.
Secondly, class bytecode operation function means Instrumentation, namely java, lang, instrument is a new characteristic of JavaSE 5, and by using Instrumentation, a developer can construct an Agent (Agent) independent of an application program to monitor and assist programs running on the JVM, and even replace and modify definitions of certain classes. Java Byte code (Byte-code) is a virtual instruction format executed by a Java virtual machine.
In some embodiments, taking mock data as an order state as an example, a tester may select states of finish, cancel, etc. in a drop-down box; the states of finish, cancel, etc. can also be directly input in the input box.
At block 270; receiving an attribute value manually modified by a tester, and taking the attribute value as a return value of the service;
in some embodiments, an attribute value is received that is manually modified by a tester for a dynamically generated value of an attribute or method, block 280 is performed, and the attribute value is returned to the front end.
In some embodiments, if the mock client 102 does not receive the attribute value obtained by manual modification within the preset time, the preset mock configuration return value is called by default, and the subsequent operation is continuously executed.
In block 280, the mock client 102 returns the return value to the front end as response data.
In some embodiments, the mcok client 102 generates return data according to the return value according to a preset response data configuration requirement, and returns the return data to the front end.
In some embodiments, the userr, account, orderType in the Ajax request is returned as is, and the return value is added as a ticket number, this json base64 is also encoded as msg, and the msg is RSA encrypted and the final result is returned to the front end.
In some embodiments, the return data may be processed/encrypted/delayed back, etc. according to the requirements of the business logic.
According to the embodiment of the disclosure, the following technical effects are achieved:
in the testing process, the server does not need to configure the mock and update to the redis, and notify the web service to restart the mock client, and the client reloads the data in the redis to load a new mock configuration when restarting; the return value can be manually modified in the mock service execution process, so that the test quantity and the test time are greatly reduced.
It is noted that while for simplicity of explanation, the foregoing method embodiments have been described as a series of acts or combination of acts, it will be appreciated by those skilled in the art that the present disclosure is not limited by the order of acts, as some steps may, in accordance with the present disclosure, occur in other orders and concurrently. Further, those skilled in the art should also appreciate that the embodiments described in the specification are exemplary embodiments and that acts and modules referred to are not necessarily required by the disclosure.
The above is a description of embodiments of the method, and the embodiments of the apparatus are further described below.
Fig. 3 shows a block diagram of a dynamic bytecode-based mock data device 300 according to an embodiment of the disclosure. Device 300 may include a mock client 102, a mock configuration end 104; wherein the content of the first and second substances,
the Mock configuration end 102 is used for inserting dynamic byte codes into a Mock service of a Mock client and annotating the dynamic byte codes; starting a mock client;
a mock client 104 for checking whether the mock service is annotated; if yes, the mock service is produced into manually modifiable attributes or methods through dynamic byte codes and displayed to testing personnel; receiving an attribute value manually modified by a tester, and taking the attribute value as a return value of the mock service; and returning the return value to the front end.
It can be clearly understood by those skilled in the art that, for convenience and brevity of description, the specific working process of the described module may refer to the corresponding process in the foregoing method embodiment, and is not described herein again.
FIG. 4 shows a schematic block diagram of an electronic device 400 that may be used to implement embodiments of the present disclosure. Device 400 may be used to implement at least one of message system 104 and message arrival rate determination system 106 of fig. 1. As shown, device 400 includes a Central Processing Unit (CPU)401 that may perform various appropriate actions and processes in accordance with computer program instructions stored in a Read Only Memory (ROM)402 or loaded from a storage unit 408 into a Random Access Memory (RAM) 403. In the RAM 403, various programs and data required for the operation of the device 400 can also be stored. The CPU401, ROM 402, and RAM 403 are connected to each other via a bus 404. An input/output (I/O) interface 405 is also connected to bus 404.
A number of components in device 400 are connected to I/O interface 405, including: an input unit 406 such as a keyboard, a mouse, or the like; an output unit 407 such as various types of displays, speakers, and the like; a storage unit 408 such as a magnetic disk, optical disk, or the like; and a communication unit 409 such as a network card, modem, wireless communication transceiver, etc. The communication unit 409 allows the device 400 to exchange information/data with other devices via a computer network, such as the internet, and/or various telecommunication networks.
The functions described herein above may be performed, at least in part, by one or more hardware logic components. For example, without limitation, exemplary types of hardware logic components that may be used include: a Field Programmable Gate Array (FPGA), an Application Specific Integrated Circuit (ASIC), an Application Specific Standard Product (ASSP), a system on a chip (SOC), a load programmable logic device (CPLD), and the like.
Program code for implementing the methods of the present disclosure may be written in any combination of one or more programming languages. These program codes may be provided to a processor or controller of a general purpose computer, special purpose computer, or other programmable data processing apparatus, such that the program codes, when executed by the processor or controller, cause the functions/operations specified in the flowchart and/or block diagram to be performed. The program code may execute entirely on the machine, partly on the machine, as a stand-alone software package partly on the machine and partly on a remote machine or entirely on the remote machine or server.
In the context of this disclosure, a machine-readable medium may be a tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device. The machine-readable medium may be a machine-readable signal medium or a machine-readable storage medium. A machine-readable medium may include, but is not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any suitable combination of the foregoing. More specific examples of a machine-readable storage medium would include an electrical connection based on one or more wires, a portable computer diskette, a hard disk, a Random Access Memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing.
Further, while operations are depicted in a particular order, this should be understood as requiring that such operations be performed in the particular order shown or in sequential order, or that all illustrated operations be performed, to achieve desirable results. Under certain circumstances, multitasking and parallel processing may be advantageous. Likewise, while several specific implementation details are included in the above discussion, these should not be construed as limitations on the scope of the disclosure. Certain features that are described in the context of separate embodiments can also be implemented in combination in a single implementation. Conversely, various features that are described in the context of a single implementation can also be implemented in multiple implementations separately or in any suitable subcombination.
Although the subject matter has been described in language specific to structural features and/or methodological acts, it is to be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or acts described above. Rather, the specific features and acts described above are disclosed as example forms of implementing the claims.
Claims (10)
1. A mock data method based on dynamic byte codes is characterized by comprising the following steps:
inserting dynamic byte codes into the Mock service of the Mock client side by the Mock configuration end and annotating the dynamic byte codes; starting a mock client;
the mock client checks whether the mock service has annotation;
if yes, the mock service is produced into manually modifiable attributes or methods through dynamic byte codes and displayed to testing personnel;
receiving an attribute value manually modified by a tester, and taking the attribute value as a return value of the mock service; and returning the return value to the front end.
2. The method of claim 1, wherein the Mock configuration end inserting and annotating dynamic bytecodes into the Mock service of the Mock client comprises:
and the Mock configuration end receives a configuration instruction input by a tester, and inserts a dynamic bytecode into the Mock service of the Mock client according to the configuration instruction and annotates the Mock service.
3. The method of claim 2, wherein the annotation is located in the mock service before the start of the code of the attribute or method that needs to be dynamically modified.
4. The method of claim 3, wherein the mock client checking whether the mock service has an annotation further comprises:
and intercepting a request sent by the front end by the Mock client, and starting the corresponding Mock service.
5. The method of claim 1, further comprising:
and if the mock service has no annotation, executing the appointed corresponding mock service according to the preset mock configuration.
6. The method of claim 1, wherein producing the mock service as manually modifiable attributes by dynamic bytecode or the method comprises:
a drop-down box or input box is generated to receive attribute values that are manually modified by a tester.
7. The method of claim 1, further comprising:
and if the attribute value manually modified by the tester is not received within the preset time, executing the appointed corresponding mock service according to the preset mock configuration.
8. A mock data device based on dynamic bytecode, comprising:
the Mock configuration end is used for inserting dynamic byte codes into the Mock service of the Mock client and annotating the dynamic byte codes; starting a mock client;
the mock client is used for checking whether the mock service is annotated; if yes, the mock service is produced into manually modifiable attributes or methods through dynamic byte codes and displayed to testing personnel; receiving an attribute value manually modified by a tester, and taking the attribute value as a return value of the mock service; and returning the return value to the front end.
9. An electronic device comprising a memory and a processor, the memory having stored thereon a computer program, wherein the processor, when executing the program, implements the method of any of claims 1-7.
10. A computer-readable storage medium, on which a computer program is stored, which program, when being executed by a processor, carries out the method according to any one of claims 1 to 7.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010637255.4A CN111797020A (en) | 2020-07-03 | 2020-07-03 | Mock data method and device based on dynamic bytecode |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010637255.4A CN111797020A (en) | 2020-07-03 | 2020-07-03 | Mock data method and device based on dynamic bytecode |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN111797020A true CN111797020A (en) | 2020-10-20 |
Family
ID=72810313
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202010637255.4A Pending CN111797020A (en) | 2020-07-03 | 2020-07-03 | Mock data method and device based on dynamic bytecode |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN111797020A (en) |
Cited By (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN112948727A (en) * | 2021-03-30 | 2021-06-11 | 平安科技（深圳）有限公司 | WebView-based data injection method, device, equipment and storage medium |
| CN113326184A (en) * | 2021-05-11 | 2021-08-31 | 前海飞算云智软件科技(深圳)有限公司 | Interface testing method and device, storage medium and electronic equipment |
| CN113342353A (en) * | 2021-07-01 | 2021-09-03 | 银联商务股份有限公司 | Mock data generation method and device |
| CN115344502A (en) * | 2022-10-18 | 2022-11-15 | 中建电子商务有限责任公司 | Method for automatically generating mock data and automatically loading mock data based on real data |
Citations (7)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20130007714A1 (en) * | 2011-06-29 | 2013-01-03 | International Business Machines Corporation | Automated testing process |
| CN108345535A (en) * | 2017-12-26 | 2018-07-31 | 阿里巴巴集团控股有限公司 | Mock test methods, device and equipment |
| CN108733399A (en) * | 2017-04-13 | 2018-11-02 | 北京京东尚科信息技术有限公司 | The method and apparatus that dynamic updates configuration data |
| CN109558320A (en) * | 2018-11-28 | 2019-04-02 | 深圳前海微众银行股份有限公司 | System detection method, device, system, equipment and computer readable storage medium |
| CN109739656A (en) * | 2018-11-29 | 2019-05-10 | 东软集团股份有限公司 | Interface data analogy method, device, storage medium and electronic equipment |
| CN110362472A (en) * | 2019-05-31 | 2019-10-22 | 口碑(上海)信息技术有限公司 | MOCK test method, device and equipment |
| CN111159033A (en) * | 2019-12-25 | 2020-05-15 | 口碑(上海)信息技术有限公司 | Software testing method and device |
-
2020
- 2020-07-03 CN CN202010637255.4A patent/CN111797020A/en active Pending
Patent Citations (7)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20130007714A1 (en) * | 2011-06-29 | 2013-01-03 | International Business Machines Corporation | Automated testing process |
| CN108733399A (en) * | 2017-04-13 | 2018-11-02 | 北京京东尚科信息技术有限公司 | The method and apparatus that dynamic updates configuration data |
| CN108345535A (en) * | 2017-12-26 | 2018-07-31 | 阿里巴巴集团控股有限公司 | Mock test methods, device and equipment |
| CN109558320A (en) * | 2018-11-28 | 2019-04-02 | 深圳前海微众银行股份有限公司 | System detection method, device, system, equipment and computer readable storage medium |
| CN109739656A (en) * | 2018-11-29 | 2019-05-10 | 东软集团股份有限公司 | Interface data analogy method, device, storage medium and electronic equipment |
| CN110362472A (en) * | 2019-05-31 | 2019-10-22 | 口碑(上海)信息技术有限公司 | MOCK test method, device and equipment |
| CN111159033A (en) * | 2019-12-25 | 2020-05-15 | 口碑(上海)信息技术有限公司 | Software testing method and device |
Non-Patent Citations (1)
| Title |
|---|
| 达芬奇密码: "使用wiremock实现动态的结果返回", pages 1 - 3, Retrieved from the Internet <URL:https://sq.sf.163.com/m/blog/article/185178614148210688> * |
Cited By (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN112948727A (en) * | 2021-03-30 | 2021-06-11 | 平安科技（深圳）有限公司 | WebView-based data injection method, device, equipment and storage medium |
| CN113326184A (en) * | 2021-05-11 | 2021-08-31 | 前海飞算云智软件科技(深圳)有限公司 | Interface testing method and device, storage medium and electronic equipment |
| CN113326184B (en) * | 2021-05-11 | 2022-05-17 | 前海飞算云智软件科技(深圳)有限公司 | Interface testing method and device, storage medium and electronic equipment |
| CN113342353A (en) * | 2021-07-01 | 2021-09-03 | 银联商务股份有限公司 | Mock data generation method and device |
| CN115344502A (en) * | 2022-10-18 | 2022-11-15 | 中建电子商务有限责任公司 | Method for automatically generating mock data and automatically loading mock data based on real data |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US9268539B2 (en) | User interface component | |
| CN111797020A (en) | Mock data method and device based on dynamic bytecode | |
| US8359576B2 (en) | Using symbolic execution to check global temporal requirements in an application | |
| CA2925015C (en) | System and method for testing data representation for different mobile devices | |
| EP1650663A2 (en) | Automated Software Testing using a layered architecture | |
| US7426717B1 (en) | System and method for debugging files in a runtime environment | |
| US8868976B2 (en) | System-level testcase generation | |
| US9189213B2 (en) | Automatic configuration of project system from project capabilities | |
| CN113238929B (en) | Code testing method and device based on Mock data, electronic equipment and storage medium | |
| CN110196720B (en) | Optimization method for generating dynamic link library by Simulink | |
| CN112148278A (en) | Visual block chain intelligent contract framework and intelligent contract development and deployment method | |
| US9715372B2 (en) | Executable guidance experiences based on implicitly generated guidance models | |
| CN113018870A (en) | Data processing method and device and computer readable storage medium | |
| CN114168190A (en) | Interface document generation method and device, computer equipment and storage medium | |
| CN112632333A (en) | Query statement generation method, device, equipment and computer readable storage medium | |
| CN112579475A (en) | Code testing method, device, equipment and readable storage medium | |
| CN108885574B (en) | System for monitoring and reporting performance and correctness issues at design, compilation, and runtime | |
| CN111831277B (en) | Virtual data generation method, system, device and computer readable storage medium | |
| CN114911541A (en) | Configuration information processing method and device, electronic equipment and storage medium | |
| CN111930478A (en) | Service calling method and device based on dynamic bytecode | |
| CN110309062A (en) | Case generation method, device, electronic equipment and storage medium | |
| CN111625465B (en) | Program generation method, device and system and electronic equipment | |
| CN117873482A (en) | Code verification method, device and equipment of intelligent contract and storage medium | |
| CN114490398A (en) | Method, device and equipment for testing consumer object | |
| CN115509923A (en) | Unit test case generation method and device and computer storage medium |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination |