Test method, device, storage medium and electronic device

Abstract

The present disclosure relates to a test method, device, storage medium and electronic equipment for establishing the association between abnormal return data and client crash data, quickly and accurately locating the cause of client crash, comprising: obtaining a data mutation strategy, and taking the obtaining time as the start consumption time; receiving the request response information returned by the server; modifying the request response information based on the data mutation strategy through the first thread to obtain the mutation response information, and sending the mutation response information to the test device, setting the completion state identifier of the data mutation strategy, running the second thread according to the preset time interval, if the completion state identifier of the data mutation strategy is read during the running of the second thread, taking the running time of the second thread as the consumption success time, if the test device crashes, establishing the association between the crash information and the mutation response information according to the comparison result of the timestamp of the crash information and the start consumption time and the consumption success time.

Description

Technical Field

[0001] This disclosure relates to the field of testing technology, and more specifically, to a testing method, apparatus, storage medium, and electronic device. Background Technology

[0002] Robustness testing, also known as fault tolerance testing, is used to test whether a system can automatically recover or ignore failures and continue operating when they occur. In related technologies, client-side robustness tools involve modifying the server's returned data during automated client-side testing to examine the client's protection handling when abnormal data is returned. If the client crashes after receiving modified abnormal data, developers need to manually investigate the cause of the crash, which consumes significant manpower and time and cannot quickly and accurately pinpoint the cause of the client-side crash. Summary of the Invention

[0003] This summary section is provided to briefly introduce the concepts, which will be described in detail in the detailed description section below. This summary section is not intended to identify key or essential features of the claimed technical solution, nor is it intended to limit the scope of the claimed technical solution.

[0004] Firstly, this disclosure provides a testing method, the method comprising:

[0005] A data mutation policy is obtained, and the time when the data mutation policy is obtained is taken as the start consumption time of the data mutation policy. The data mutation policy is used to modify the response information of the network request.

[0006] Receive a first network request sent by the test device, send the first network request to the server, and receive the request response information returned by the server in response to the first network request;

[0007] The first thread modifies the request response information based on the data mutation strategy to obtain mutation response information, and sends the mutation response information to the test device, and sets a completion status flag for the data mutation strategy;

[0008] The second thread runs at a preset time interval. If the completion status flag of the data mutation policy is read when the second thread is running, the running time of the second thread is taken as the successful consumption time of the data mutation policy. The second thread runs in parallel with the first thread.

[0009] If the test device crashes, the timestamp of the crash information is determined, and the association between the crash information and the mutation response information is established based on the comparison between the time represented by the timestamp and the start time and successful time of the data mutation strategy.

[0010] Secondly, this disclosure provides a testing apparatus, the apparatus comprising:

[0011] The acquisition module is used to acquire a data mutation strategy and use the time of acquiring the data mutation strategy as the start consumption time of the data mutation strategy. The data mutation strategy is used to modify the response information of the network request.

[0012] The first receiving module is used to receive a first network request sent by the test device, send the first network request to the server, and receive the request response information returned by the server in response to the first network request.

[0013] The first modification module is used to modify the request response information based on the data mutation strategy through the first thread, obtain the mutation response information, send the mutation response information to the test device, and set a completion status flag for the data mutation strategy.

[0014] The determination module is used to run the second thread at a preset time interval. If the completion status identifier of the data mutation policy is read when the second thread is running, the running time of the second thread is taken as the consumption success time of the data mutation policy, wherein the second thread runs in parallel with the first thread.

[0015] The association module is used to determine the timestamp of the crash information when the test device crashes, and to establish an association between the crash information and the mutation response information based on the comparison between the time represented by the timestamp and the start time and successful time of the data mutation strategy.

[0016] Thirdly, this disclosure provides a non-transitory computer-readable storage medium having a computer program stored thereon that, when executed by a processing device, implements the steps of the method described in the first aspect.

[0017] Fourthly, this disclosure provides an electronic device, comprising:

[0018] A storage device on which computer programs are stored;

[0019] A processing device for executing the computer program in the storage device to implement the steps of the method in the first aspect.

[0020] The above technical solution allows the time of acquiring the data mutation strategy to be used as the start time for consuming the data mutation strategy, and the successful consumption time of the data mutation strategy is determined by a second thread running at preset time intervals. Therefore, if the test device crashes after sending the mutation response information, the timestamp of the crash information can be compared with the start time and successful consumption time of the data mutation strategy. Based on this comparison, a correlation between the crash information and the mutation response information can be established. This method allows for quick and accurate location of the cause of the test device crash, reducing the time spent on manual analysis and improving the efficiency of client robustness testing. Furthermore, because the crash information and mutation response information are promptly correlated after a crash, the data consumption capacity and timeliness of the crash information are improved.

[0021] Other features and advantages of this disclosure will be described in detail in the following detailed description section. Attached Figure Description

[0022] The above and other features, advantages, and aspects of the embodiments of this disclosure will become more apparent from the accompanying drawings and the following detailed description. Throughout the drawings, the same or similar reference numerals denote the same or similar elements. It should be understood that the drawings are schematic, and the originals and elements are not necessarily drawn to scale. In the drawings:

[0023] Figure 1 This is a flowchart illustrating a testing method according to an exemplary embodiment of the present disclosure;

[0024] Figure 2 This is a schematic diagram illustrating an implementation scenario of a testing method according to an exemplary embodiment of the present disclosure;

[0025] Figure 3 This is a schematic diagram illustrating an implementation scenario of a testing method according to another exemplary embodiment of the present disclosure;

[0026] Figure 4 This is a schematic diagram illustrating an implementation scenario of a testing method according to another exemplary embodiment of the present disclosure;

[0027] Figure 5 This is a block diagram illustrating a testing apparatus according to an exemplary embodiment of the present disclosure;

[0028] Figure 6 This is a block diagram illustrating an electronic device according to an exemplary embodiment of the present disclosure. Detailed Implementation

[0029] Embodiments of this disclosure will now be described in more detail with reference to the accompanying drawings. While some embodiments of this disclosure are shown in the drawings, it should be understood that this disclosure can be implemented in various forms and should not be construed as limited to the embodiments set forth herein. Rather, these embodiments are provided to provide a more thorough and complete understanding of this disclosure. It should be understood that the accompanying drawings and embodiments of this disclosure are for illustrative purposes only and are not intended to limit the scope of protection of this disclosure.

[0030] It should be understood that the steps described in the method embodiments of this disclosure may be performed in different orders and / or in parallel. Furthermore, the method embodiments may include additional steps and / or omit the steps shown. The scope of this disclosure is not limited in this respect.

[0031] The term "comprising" and its variations as used herein are open-ended inclusions, meaning "including but not limited to". The term "based on" means "at least partially based on". The term "one embodiment" means "at least one embodiment"; the term "another embodiment" means "at least one additional embodiment"; the term "some embodiments" means "at least some embodiments". Definitions of other terms will be given in the description below.

[0032] It should be noted that the concepts of "first" and "second" mentioned in this disclosure are used only to distinguish different devices, modules, or units, and are not used to limit the order of functions performed by these devices, modules, or units or their interdependencies. It should also be noted that the modifiers "a" and "a plurality of" mentioned in this disclosure are illustrative rather than restrictive, and those skilled in the art should understand that, unless explicitly stated otherwise in the context, they should be understood as "one or more".

[0033] The names of messages or information exchanged between multiple devices in the embodiments of this disclosure are for illustrative purposes only and are not intended to limit the scope of such messages or information.

[0034] As mentioned in the background section, client robustness tools in related technologies involve modifying the server's returned data during automated testing on the client side to examine the client's protection measures in the event of abnormal data returns. If the client crashes after receiving the modified abnormal data, developers need to manually investigate the cause of the crash, which consumes a lot of manpower and time and cannot quickly and accurately pinpoint the cause of the client crash.

[0035] In view of this, this disclosure provides a testing method to establish a correlation between abnormal return data and client crash data, thereby more quickly and accurately locating the cause of client crashes and improving the efficiency of client robustness testing.

[0036] Figure 1This is a flowchart illustrating a testing method according to an exemplary embodiment of the present disclosure. This testing method can be applied to a proxy server in a test scenario, as shown below. Figure 1 The testing method includes the following steps:

[0037] Step 101: Obtain a data mutation policy and use the time when the data mutation policy is obtained as the start time for consuming the data mutation policy. This data mutation policy is used to modify the response information of network requests.

[0038] Step 102: Receive the first network request sent by the test device, send the first network request to the server, and receive the request response information returned by the server in response to the first network request.

[0039] Step 103: Modify the request response information based on the data mutation strategy through the first thread to obtain the mutation response information, send the mutation response information to the test device, and set a completion status flag for the data mutation strategy.

[0040] Step 104: Run the second thread at preset time intervals. If the completion status flag of the data mutation policy is read during the execution of the second thread, the execution time of the second thread is taken as the successful consumption time of the data mutation policy. The second thread runs in parallel with the first thread.

[0041] Step 105: If the test device crashes, determine the timestamp of the crash information, and establish the association between the crash information and the mutation response information based on the comparison between the time represented by the timestamp and the start time and successful time of the data mutation strategy.

[0042] Using the above method, the time when the data mutation strategy is acquired can be used as the start time for consuming the data mutation strategy, and the successful consumption time of the data mutation strategy can be determined according to the second thread running at preset time intervals. Therefore, if the test device crashes after the mutation response information is sent, the timestamp of the crash information can be compared with the start time and successful consumption time of the data mutation strategy, thereby establishing a correlation between the crash information and the mutation response information based on the time comparison result.

[0043] In one possible approach, the association between crash information and mutation response information can be established if the timestamp represents a time between the start consumption time and the successful consumption time; or, if the timestamp represents a time between the start consumption time and the successful consumption time, it can be determined whether the timestamp represents a time between the start consumption time of the data mutation strategy and the start consumption time of the next acquired data mutation strategy. If the timestamp represents a time between the start consumption time of the data mutation strategy and the start consumption time of the next acquired data mutation strategy, then the association between the crash information and the mutation response information can be established.

[0044] For example, the second thread runs at a preset time interval, such as a 2-second interval, etc., but this embodiment does not limit this. After obtaining a data mutation policy, the first thread modifies the request response information based on the data mutation policy to obtain mutation response information, and sends the mutation response information to the test device. A completion status flag is set for the data mutation policy. Therefore, when the second thread, which runs in parallel with the first thread, reads the completion status flag, the current running time of the second thread can be taken as the successful consumption time of the data mutation policy.

[0045] In one possible scenario, the test device crash might occur shortly before the second thread starts running, such as one second before the second thread begins. In this case, if the timestamp represents a time between the start of consumption and the successful consumption time, a correlation can be established between the crash information and the mutation response information. In another possible scenario, the test device crash might occur precisely during the execution of the second thread, meaning the timestamp represents a time outside the start of consumption and the successful consumption time. In this case, it can be further determined whether the timestamp represents a time between the start of consumption of the current data mutation strategy and the start of consumption of the next acquired data mutation strategy. If the timestamp represents a time between the start of consumption of the current data mutation strategy and the start of consumption of the next acquired data mutation strategy, a correlation can be established between the crash information and the mutation response information.

[0046] By establishing the correlation between crash information and mutation response information using the above method, the cause of the test device crash can be quickly and accurately located based on this correlation, reducing the time spent on manual analysis of crash causes and thus improving the efficiency of client robustness testing. Furthermore, because the crash information and mutation response information are promptly correlated after a crash, the data consumption capacity and timeliness of crash information can be improved.

[0047] To enable those skilled in the art to better understand the testing methods provided in this disclosure, the above steps are illustrated in detail below.

[0048] For example, data mutation strategies are used to modify the response information of network requests, such as changing the data in the response information to a preset value. Network request responses are typically in JSON format, containing multiple data items consisting of keys and corresponding values. Therefore, data mutation strategies can be used to specify that the value corresponding to a certain key in the response information should be modified to a preset value. For instance, if the network request response information includes two keys, A and B, with A having a value of 1 and B having a value of 2, the data mutation strategy could be set to modify the value of A to NULL. Therefore, after executing this data mutation strategy, the value of A in the response information will be modified to NULL, while the value of B will remain unchanged.

[0049] In one possible approach, the data mutation strategy can be obtained as follows: A third network request is received from a test device and sent to a server. The server returns a path mapping relationship, which characterizes the correspondence between the request path and the request-response information of the third network request. This path mapping relationship is then sent to a strategy generator, which sends a data mutation strategy. This data mutation strategy is obtained by associating preset data modification rules with the request path in the path mapping relationship. Accordingly, modifying the request-response information based on the data mutation strategy can be done by: determining the request path of a first network request; if the request path of the first network request is the same as the request path in the data mutation strategy, then modifying the request-response information corresponding to the first network request based on the data mutation strategy.

[0050] It should be understood that in practical applications, each robustness test typically targets a single test scenario, meaning each robustness test usually acquires a data mutation strategy to modify the response information of a specific network request. However, a client executing an automated test may generate multiple network requests. Therefore, to accurately implement robustness testing, it is necessary to first determine whether the request path of the network request is the same as the request path corresponding to the data mutation strategy. Based on this consideration, in the process of determining the data mutation strategy, this embodiment of the disclosure establishes an association between preset data modification rules and corresponding request paths. The resulting data mutation strategy can have a corresponding request path, thereby allowing for accurate modification of the request response information of the corresponding network request based on the data mutation strategy in subsequent processes by comparing request paths, thus improving test accuracy.

[0051] For example, it can be based on Figure 2The implementation scenario shown defines a data mutation strategy. The control host issues different test configurations based on user instructions to trigger different automated test tasks and activates corresponding proxy servers, while simultaneously connecting the test device to the corresponding proxy server. For example, the control host and test device can be connected via the adb toolkit to control the test device to execute automated tests. The test device is used to run automated tests. The third proxy server forwards third network requests issued by the test device. These third network requests can be network requests issued by applications installed on the test device, which are not limited in this embodiment. Simultaneously, the third proxy server can forward the mapping between the request-response information (response information) and the request path (path) of the third network request returned by the public server to the strategy generator, and directly return the request-response data returned by the public server to the test device. The public server is a real online server. The strategy generator generates a mutation strategy based on the received request-response information and preset data modification rules, and writes it to the database.

[0052] Reference Figure 2 In specific implementation, the control host can start the third proxy server in step 1, and use the adb tool to connect to the test device in step 2 to trigger the corresponding automated test task. In step 3, the test device sends a third network request to the third proxy server. In step 4, the third proxy server forwards the request to the public network server. In step 5, the third proxy server receives the request-response information from the public network server in response to the third network request. In step 6, the third proxy server sends the correspondence between the request-response information of the third network request and the request path to the policy generator. In step 7, the third proxy server returns the request-response information to the test device. In step 8, the policy generator generates a policy according to preset data modification rules and writes it to the database.

[0053] The preset data modification rules can be set according to actual conditions, and this embodiment does not limit them. For example, the preset data modification rule can be to modify the data of a certain key name in the request response information of a network request to a preset data type or value. If the data can be found in the request response information of the public network server for a third network request, the preset data modification rule can be associated with the corresponding request path to obtain a data mutation strategy.

[0054] It should be understood that, in specific implementation, a request path may correspond to one data mutation strategy or multiple data mutation strategies. This disclosure does not limit this and can be set according to the actual situation.

[0055] In one possible approach, the data mutation policy can be written to a database. Accordingly, retrieving the data mutation policy and using the time of retrieval as the start time for consuming the data mutation policy can be done by reading the data mutation policy from the database into the proxy server's memory and using the time of reading the data mutation policy as the start time for consuming the data mutation policy.

[0056] In other words, when implementing the testing method provided in this disclosure, the data mutation policy can first be initialized from the database into the proxy server's memory. The proxy server can then directly use the data mutation policy in memory to modify the request-response information in subsequent processes, thereby improving testing efficiency. In this scenario, the start time for consuming the data mutation policy is the time when it is read from the database.

[0057] After obtaining the data mutation strategy, refer to Figure 3 In step 1, the control host can activate the first proxy server. It should be understood that this first proxy server can be a consumption-type proxy server used for the correlation testing process of crash information and mutation response information, while the third proxy server mentioned above can be a collection-type proxy server used for the process of determining the data mutation strategy. In practical applications, different types of proxy servers can be centralized on the device platform, and then the corresponding type of proxy server can be invoked by sending the unique identifier information of the proxy server to the device platform. Furthermore, it should be understood that during the first test, the first proxy server can initialize the data mutation strategy to be executed in memory from the database. After executing steps 6 and 7, the data mutation strategy to be executed by the first proxy server can be updated to another data mutation strategy. That is, before the test, the first proxy server initializes the data mutation strategy to be executed, so the test process can directly obtain the data mutation strategy from the memory of the first proxy server, thereby improving test efficiency.

[0058] Continue to refer to Figure 3In step 2, the control host can use the adb tool to connect to the test device and trigger the corresponding automated test task. In step 3, the test device sends a first network request to the first proxy server. In step 4, the first proxy server forwards the request to the public network server. In step 5, the first proxy server receives the request response information from the public network server in response to the first network request. In step 6, the first proxy server requests the database to retrieve the strategy to be executed in the next test. In step 7, the database can send the data mutation strategy for the next test to the first proxy server. That is, through steps 6 and 7, the data mutation strategy to be executed in the next test can be initialized in the memory of the first proxy server, so that the data mutation strategy can be directly retrieved from memory in the next test, improving test efficiency.

[0059] It should be understood that, as explained above, a data mutation strategy can be obtained by associating a request path with a preset data modification rule. Therefore, the data mutation strategy returned by the database can have a corresponding request path. In this case, the first proxy server can determine whether the request path of the first network request is consistent with the request path corresponding to the data mutation strategy. If they are consistent, the server can modify the request response information of the first network request based on the data mutation strategy to obtain the mutated response information. Then, in step 8, the mutated response information is sent to the test device.

[0060] In this process, the time when the data mutation policy is acquired can be used as the start time for consuming the data mutation policy, and the successful consumption time of the data mutation policy can be determined according to the second thread running at preset time intervals. Therefore, if the test device crashes after the mutation response information is sent, the crash information can be reported to the control host in step 9. Furthermore, the timestamp of the crash information can be compared with the start time and successful consumption time of the data mutation policy. Based on the time comparison result, a correlation between the crash information and the mutation response information can be established. This correlation allows for quick and accurate location of the cause of the test device crash, reducing the time spent on manual analysis of the crash cause and improving the efficiency of client robustness testing.

[0061] In one possible approach, a second network request sent by the test device can be received, forwarded to the server, and the server's response information can be received. Then, the response information of the second network request is modified based on a data mutation strategy to obtain reproduced mutation response information, which is then sent to the test device. If the test device crashes, its current crash information is used as reproduced crash information. Accordingly, establishing the association between the crash information and the mutation response information can be achieved if the stack trace of the crash information matches the stack trace of the reproduced crash information.

[0062] In practical applications, if the test equipment crashes after the mutation response information is sent, it may be due to some accidental reason, rather than a problem with the test equipment itself. In this case, to ensure the accuracy of the test, a crash reproduction test can be performed.

[0063] For example, refer to Figure 4 The control host can start the second proxy server in step 1. It should be understood that this second proxy server can be a reproduction-type proxy server used for the crash information reproduction testing process. In practical applications, different types of proxy servers can be centralized on the device platform, and then the corresponding type of proxy server can be invoked by sending the unique identifier information of the proxy server to the device platform. Furthermore, it should be understood that during the first test, the second proxy server can initialize the data mutation policy to be executed in memory from the database. After executing steps 6 and 7, the data mutation policy to be executed by the second proxy server can be updated to another data mutation policy. That is, the second proxy server initializes the data mutation policy to be executed before the test, so the test process can directly obtain the data mutation policy from the memory of the second proxy server, thereby improving test efficiency.

[0064] Continue to refer to Figure 4In step 2, the control host can use the adb tool to connect to the test device and trigger the corresponding automated test task. In step 3, the test device sends a second network request to the second proxy server. In step 4, the second proxy server forwards the request to the public network server. In step 5, the second proxy server receives the request response information from the public network server in response to the second network request. In step 6, the second proxy server can request the database to retrieve the strategy to be executed in the next test. In step 7, the database can send the data mutation strategy for the next test to the second proxy server. That is, through steps 6 and 7, the data mutation strategy to be executed in the next test can be initialized in the memory of the second proxy server, so that the data mutation strategy can be directly retrieved from memory in the next test, improving test efficiency.

[0065] The second proxy server can modify the request-response information of the second network request based on the data mutation strategy to obtain reproduced mutation response information. Then, in step 8, the reproduced mutation response information is sent to the test device. If the test device crashes, the crash information can be reported in step 9. The current crash information of the test device can be used as reproduced crash information. Afterwards, the stack information of the reproduced crash information and the crash information generated by the test device after receiving the mutation response information can be compared. If they are consistent, it indicates that the crash is reproducible, thereby establishing a correlation between the crash information and the mutation response information to improve the accuracy of the correlation and thus improve the accuracy of robustness testing.

[0066] In one possible approach, modifying the request-response information based on a data mutation strategy to obtain mutated response information can be achieved by: first determining the target data in the response information of the network request to be modified by the data mutation strategy, wherein the value of the target data includes at least one sub-data consisting of a key name and a corresponding value; then converting the data mutation strategy into a sub-data mutation strategy for each sub-data; and finally modifying the request-response information of the first network request according to the sub-data mutation strategy corresponding to each sub-data to obtain mutated response information.

[0067] In practical applications, network request responses are typically in JSON format, consisting of keys and their corresponding values. The value corresponding to a given key may also be JSON data composed of a key and its corresponding value. For example, the value corresponding to key C might include a first piece of data with key c1 and a value of 1, and a second piece of data with key c2 and a value of 2. In this case, if the data mutation strategy targets key C, such as changing its value to NULL, the response might be modified by directly setting the value of key C to NULL. However, another possibility is to modify the values ​​of both the first and second pieces of data to NULL. In the latter case, if the test device crashes, it becomes impossible to accurately determine whether the crash was caused by the modification of the first or second piece of data.

[0068] Therefore, to more accurately pinpoint the cause of the crash, the data mutation strategy can be broken down into sub-data mutation strategies for each sub-data element. Then, based on the sub-data mutation strategy for each sub-data element, the request and response information of the first network request is modified to obtain mutated response information. It should be understood that in this case, multiple mutated response messages can be obtained. These multiple mutated response messages can then be sent to the test device to determine if the test device has crashed. If the test device has crashed, the corresponding mutated response messages can be correlated with the crash information. This allows the crash information to be located at a finer-grained data level, thereby more accurately pinpointing the cause of the test device crash and improving testing accuracy.

[0069] After establishing the correlation between crash information and mutation response information, the crash information and the correlation between crash information and mutation response information can be reported to the target server so that the crash information and correlation can be obtained through the target server's data acquisition interface to determine the cause of the test device's crash.

[0070] For example, the target server can be an HTTP server specified according to the actual situation. Detailed information related to the crash (i.e., crash information) and the correlation between the crash information and the mutation response information can be reported to the target server. The corresponding information can then be obtained through the target server's data acquisition interface to determine the cause of the test device's crash. Compared to related technologies that only report crash information and then have developers manually analyze the crash cause, the method provided in this disclosure allows developers to more quickly locate the crash cause based on the reported correlation, thereby improving testing efficiency.

[0071] It should be understood that the testing methods provided in this disclosure can include three processes: data collection, data consumption, and data reproduction. Data collection can be referred to... Figure 2The implementation process shown involves testing via a third-party proxy server and testing equipment to determine the data mutation strategy. The specific process can be found above. Data consumption can be referenced... Figure 3 The implementation process shown involves testing through a first proxy server and testing equipment to iterate through the data mutation strategies determined during data collection and to initially establish the correlation between crash information and mutation response information. Data reproduction can be referenced... Figure 4 The implementation process shown involves testing through a second proxy server and testing equipment. If the crash generated by this process based on the same data mutation strategy is consistent with the crash generated by the data consumption process, the correlation between the crash information and the mutation response information can be reported. This facilitates the analysis of the crash cause based on the correlation, thereby improving the efficiency of robustness testing.

[0072] Based on the same concept, this disclosure also provides a testing apparatus that can be part or all of an electronic device through software, hardware, or a combination of both. (See also...) Figure 5 The testing apparatus 500 may include:

[0073] The acquisition module 501 is used to acquire a data mutation strategy and use the time of acquiring the data mutation strategy as the start consumption time of the data mutation strategy. The data mutation strategy is used to modify the response information of the network request.

[0074] The first receiving module 502 is used to receive a first network request sent by the test device, send the first network request to the server, and receive the request response information returned by the server in response to the first network request.

[0075] The first modification module 503 is used to modify the request response information based on the data mutation strategy through the first thread, obtain the mutation response information, send the mutation response information to the test device, and set a completion status flag for the data mutation strategy.

[0076] The determination module 504 is used to run the second thread at a preset time interval. If the completion status identifier of the data mutation policy is read when the second thread is running, the running time of the second thread is taken as the consumption success time of the data mutation policy, wherein the second thread runs in parallel with the first thread.

[0077] The association module 505 is used to determine the timestamp of the crash information when the test device crashes, and to establish an association between the crash information and the mutation response information based on the comparison result between the time represented by the timestamp and the start time and successful time of the data mutation strategy.

[0078] Optionally, the association module 505 is used for:

[0079] If the time represented by the timestamp falls between the start consumption time and the successful consumption time, establish an association between the crash information and the mutation response information; or

[0080] If the time represented by the timestamp is not between the start consumption time and the consumption success time, determine whether the time represented by the timestamp is between the start consumption time of the data mutation strategy and the start consumption time of the next acquired data mutation strategy;

[0081] If the time represented by the timestamp is between the start consumption time of the data mutation strategy and the start consumption time of the next acquired data mutation strategy, an association is established between the crash information and the mutation response information.

[0082] Optionally, the device 500 further includes:

[0083] The second receiving module is used to receive the second network request sent by the test device, send the second network request to the server, and receive the request response information returned by the server in response to the second network request.

[0084] The second modification module is used to modify the request response information of the second network request based on the data mutation strategy through the first thread to obtain the reproduced mutation response information, and send the reproduced mutation response information to the test device through the first thread. When the test device crashes, the current crash information of the test device is used as the reproduced crash information.

[0085] The association module 505 is used for:

[0086] When the stack information of the crash information is consistent with the stack information of the reproduced crash information, an association relationship is established between the crash information and the mutation response information.

[0087] Optionally, the first modification module 503 is used to:

[0088] The data mutation strategy is determined to be used to modify target data in the response information of a network request, wherein the value of the target data includes at least one sub-data consisting of a key name and a corresponding value;

[0089] The data mutation strategy is converted into a sub-data mutation strategy for each sub-data item;

[0090] The request response information of the first network request is modified according to the sub-data mutation strategy corresponding to each sub-data to obtain the mutated response information.

[0091] Optionally, the device further includes a data collection module for:

[0092] The system receives a third network request sent by the test device and sends the third network request to the server. It also receives a path correspondence returned by the server, which is used to characterize the correspondence between the request path of the third network request and the request response information of the third network request.

[0093] The path mapping relationship is sent to the strategy generator, and the data mutation strategy returned by the strategy generator is received. The data mutation strategy is obtained by the strategy generator by establishing an association between the preset data modification rules and the request path in the mapping relationship.

[0094] The first modification module 503 is used for:

[0095] Determine the request path of the first network request. When the request path of the first network request is the same as the request path corresponding to the data mutation strategy, modify the request response information corresponding to the first network request based on the data mutation strategy.

[0096] Optionally, the data mutation strategy is pre-written into the database, and the acquisition module 501 is used for:

[0097] The data mutation policy is read from the database into the proxy server's memory, and the time when the data mutation policy is read is taken as the start time of consuming the data mutation policy.

[0098] Optionally, the device 500 further includes:

[0099] The reporting module is used to report the crash information and the correlation between the crash information and the mutation response information to the target server, so as to obtain the crash information and the correlation through the data acquisition interface of the target server to determine the cause of the test device crash.

[0100] Regarding the apparatus in the above embodiments, the specific manner in which each module performs its operation has been described in detail in the embodiments related to the method, and will not be elaborated upon here.

[0101] Based on the same concept, embodiments of this disclosure also provide a non-transitory computer-readable storage medium having a computer program stored thereon that, when executed by a processing device, implements the steps of any of the above-described test methods.

[0102] Based on the same concept, embodiments of this disclosure also provide an electronic device, including:

[0103] A storage device on which computer programs are stored;

[0104] A processing device for executing the computer program in the storage device to implement the steps of any of the above-described test methods.

[0105] The following is for reference. Figure 6 This diagram illustrates a structural schematic of an electronic device 600 suitable for implementing embodiments of the present disclosure. The terminal devices in the embodiments of the present disclosure may include, but are not limited to, mobile terminals such as mobile phones, laptops, digital broadcast receivers, PDAs (personal digital assistants), PADs (tablet computers), PMPs (portable multimedia players), in-vehicle terminals (e.g., in-vehicle navigation terminals), and fixed terminals such as digital TVs and desktop computers. Figure 6 The electronic device shown is merely an example and should not be construed as limiting the functionality and scope of the embodiments disclosed herein.

[0106] like Figure 6 As shown, electronic device 600 may include a processing device (e.g., a central processing unit, a graphics processor, etc.) 601, which can perform various appropriate actions and processes according to a program stored in read-only memory (ROM) 602 or a program loaded from storage device 608 into random access memory (RAM) 603. RAM 603 also stores various programs and data required for the operation of electronic device 600. Processing device 601, ROM 602, and RAM 603 are interconnected via bus 604. Input / output (I / O) interface 605 is also connected to bus 604.

[0107] Typically, the following devices can be connected to I / O interface 605: input devices 606 including, for example, touchscreens, touchpads, keyboards, mice, cameras, microphones, accelerometers, gyroscopes, etc.; output devices 607 including, for example, liquid crystal displays (LCDs), speakers, vibrators, etc.; storage devices 608 including, for example, magnetic tapes, hard disks, etc.; and communication devices 609. Communication device 609 allows electronic device 600 to communicate wirelessly or wiredly with other devices to exchange data. Although Figure 6 An electronic device 600 with various devices is shown; however, it should be understood that it is not required to implement or possess all of the devices shown. More or fewer devices may be implemented or possessed alternatively.

[0108] In particular, according to embodiments of this disclosure, the processes described above with reference to the flowcharts can be implemented as computer software programs. For example, embodiments of this disclosure include a computer program product comprising a computer program carried on a non-transitory computer-readable medium, the computer program containing program code for performing the methods shown in the flowcharts. In such embodiments, the computer program can be downloaded and installed from a network via a communication device 609, or installed from a storage device 608, or installed from a ROM 602. When the computer program is executed by the processing device 601, it performs the functions defined in the methods of embodiments of this disclosure.

[0109] It should be noted that the computer-readable medium described in this disclosure can be a computer-readable signal medium or a computer-readable storage medium, or any combination thereof. A computer-readable storage medium can be, for example,—but not limited to—an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination thereof. More specific examples of a computer-readable storage medium may include, but are not limited to: an electrical connection having one or more wires, a portable computer disk, a hard disk, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), optical storage device, magnetic storage device, or any suitable combination thereof. In this disclosure, a computer-readable storage medium can be any tangible medium containing or storing a program that can be used by or in connection with an instruction execution system, apparatus, or device. In this disclosure, a computer-readable signal medium can include a data signal propagated in baseband or as part of a carrier wave, carrying computer-readable program code. Such propagated data signals can take various forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination thereof. A computer-readable signal medium can be any computer-readable medium other than a computer-readable storage medium, which can send, propagate, or transmit a program for use by or in connection with an instruction execution system, apparatus, or device. The program code contained on the computer-readable medium can be transmitted using any suitable medium, including but not limited to: wires, optical fibers, RF (radio frequency), etc., or any suitable combination thereof.

[0110] In some implementations, communication can be conducted using any currently known or future-developed network protocol such as HTTP (Hypertext Transfer Protocol), and can be interconnected with digital data communication (e.g., communication networks) of any form or medium. Examples of communication networks include local area networks (“LANs”), wide area networks (“WANs”), the Internet (e.g., the Internet of Things), and end-to-end networks (e.g., ad hoc end-to-end networks), as well as any currently known or future-developed networks.

[0111] The aforementioned computer-readable medium may be included in the aforementioned electronic device; or it may exist independently and not assembled into the electronic device.

[0112] The aforementioned computer-readable medium carries one or more programs. When the electronic device executes the aforementioned one or more programs, the electronic device causes the following: It acquires a data mutation policy and uses the time of acquiring the data mutation policy as the start consumption time of the data mutation policy, wherein the data mutation policy is used to modify the response information of a network request; it receives a first network request sent by a test device and sends the first network request to a server, and receives request response information returned by the server for the first network request; it modifies the request response information based on the data mutation policy through a first thread to obtain mutation response information, and sends the mutation response information to the test device, setting a completion status flag for the data mutation policy; it runs a second thread at preset time intervals, and if the completion status flag of the data mutation policy is read during the execution of the second thread, the execution time of the second thread is used as the successful consumption time of the data mutation policy, wherein the second thread runs in parallel with the first thread; if the test device crashes, it determines the timestamp of the crash information, and compares the time represented by the timestamp with the start consumption time and successful consumption time of the data mutation policy to establish an association between the crash information and the mutation response information.

[0113] Computer program code for performing the operations of this disclosure can be written in one or more programming languages ​​or a combination thereof, including but not limited to object-oriented programming languages ​​such as Java, Smalltalk, and C++, as well as conventional procedural programming languages ​​such as the "C" language or similar programming languages. The program code can be executed entirely on the user's computer, partially on the user's computer, as a standalone software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In cases involving remote computers, the remote computer can be connected to the user's computer via any type of network—including a local area network (LAN) or a wide area network (WAN)—or can be connected to an external computer (e.g., via the Internet using an Internet service provider).

[0114] The flowcharts and block diagrams in the accompanying drawings illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of this disclosure. In this regard, each block in a flowchart or block diagram may represent a module, segment, or portion of code containing one or more executable instructions for implementing a specified logical function. It should also be noted that in some alternative implementations, the functions indicated in the blocks may occur in a different order than those indicated in the drawings. For example, two consecutively indicated blocks may actually be executed substantially in parallel, and they may sometimes be executed in reverse order, depending on the functions involved. It should also be noted that each block in the block diagrams and / or flowcharts, and combinations of blocks in the block diagrams and / or flowcharts, can be implemented using a dedicated hardware-based system that performs the specified function or operation, or using a combination of dedicated hardware and computer instructions.

[0115] The modules described in the embodiments of this disclosure can be implemented in software or hardware. The names of the modules are not, in some cases, intended to limit the functionality of the module itself.

[0116] The functions described above in this document can be performed, at least in part, by one or more hardware logic components. For example, exemplary types of hardware logic components that can be used, without limitation, include: Field Programmable Gate Arrays (FPGAs), Application-Specific Integrated Circuits (ASICs), Application Standard Products (ASSPs), System-on-Chip (SoCs), Complex Programmable Logic Devices (CPLDs), and so on.

[0117] In the context of this disclosure, a machine-readable medium can be a tangible medium that may contain or store a program for use by or in conjunction with an instruction execution system, apparatus, or device. A machine-readable medium can be a machine-readable signal medium or a machine-readable storage medium. A machine-readable medium can be, but is not limited to, electronic, magnetic, optical, electromagnetic, infrared, or semiconductor systems, apparatus, or devices, or any suitable combination of the foregoing. More specific examples of machine-readable storage media include electrical connections based on one or more wires, portable computer disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination of the foregoing.

[0118] According to one or more embodiments of this disclosure, Example 1 provides a testing method, including:

[0119] A data mutation policy is obtained, and the time when the data mutation policy is obtained is taken as the start consumption time of the data mutation policy. The data mutation policy is used to modify the response information of the network request.

[0120] Receive a first network request sent by the test device, send the first network request to the server, and receive the request response information returned by the server in response to the first network request;

[0121] The first thread modifies the request response information based on the data mutation strategy to obtain mutation response information, and sends the mutation response information to the test device, and sets a completion status flag for the data mutation strategy;

[0122] The second thread runs at a preset time interval. If the completion status flag of the data mutation policy is read when the second thread is running, the running time of the second thread is taken as the successful consumption time of the data mutation policy. The second thread runs in parallel with the first thread.

[0123] If the test device crashes, the timestamp of the crash information is determined, and the association between the crash information and the mutation response information is established based on the comparison between the time represented by the timestamp and the start time and successful time of the data mutation strategy.

[0124] According to one or more embodiments of this disclosure, Example 2 provides the method of Example 1, wherein establishing the association between the crash information and the mutation response information based on a comparison result between the time represented by the timestamp and the start consumption time and successful consumption time of the data mutation strategy includes:

[0125] If the time represented by the timestamp falls between the start consumption time and the successful consumption time, establish an association between the crash information and the mutation response information; or

[0126] If the time represented by the timestamp is not between the start consumption time and the consumption success time, determine whether the time represented by the timestamp is between the start consumption time of the data mutation strategy and the start consumption time of the next acquired data mutation strategy;

[0127] If the time represented by the timestamp is between the start consumption time of the data mutation strategy and the start consumption time of the next acquired data mutation strategy, then an association is established between the crash information and the mutation response information.

[0128] According to one or more embodiments of this disclosure, Example 3 provides the method of Example 1 or 2, the method further comprising:

[0129] Receive a second network request sent by the test device, send the second network request to the server, and receive the request response information returned by the server in response to the second network request;

[0130] The first thread modifies the request-response information of the second network request based on the data mutation strategy to obtain the reproduced mutation response information, and sends the reproduced mutation response information to the test device through the first thread. If the test device crashes, the current crash information of the test device is used as the reproduced crash information.

[0131] Establishing the association between the crash information and the mutation response information includes:

[0132] If the stack information of the crash information is consistent with the stack information of the reproduced crash information, then an association relationship is established between the crash information and the mutation response information.

[0133] According to one or more embodiments of this disclosure, Example 4 provides a method of Example 1 or 2, wherein modifying the request response information based on the data mutation strategy to obtain mutated response information includes:

[0134] The data mutation strategy is determined to be used to modify target data in the response information of a network request, wherein the value of the target data includes at least one sub-data consisting of a key name and a corresponding value;

[0135] The data mutation strategy is converted into a sub-data mutation strategy for each sub-data item;

[0136] The request response information of the first network request is modified according to the sub-data mutation strategy corresponding to each sub-data to obtain the mutated response information.

[0137] According to one or more embodiments of this disclosure, Example 5 provides the method of Example 1 or 2, wherein the data mutation strategy is obtained in the following manner:

[0138] The system receives a third network request sent by the test device and sends the third network request to the server. It also receives a path correspondence returned by the server, which is used to characterize the correspondence between the request path of the third network request and the request response information of the third network request.

[0139] The path mapping relationship is sent to the strategy generator, and the data mutation strategy returned by the strategy generator is received. The data mutation strategy is obtained by the strategy generator by associating the preset data modification rules with the request path in the mapping relationship.

[0140] Modifying the request-response information based on the data mutation strategy includes:

[0141] Determine the request path of the first network request. If the request path of the first network request is the same as the request path corresponding to the data mutation strategy, modify the request response information corresponding to the first network request based on the data mutation strategy.

[0142] According to one or more embodiments of this disclosure, Example 6 provides a method of Example 1 or 2, wherein the data mutation strategy is pre-written into a database, and the step of obtaining the data mutation strategy and using the time of obtaining the data mutation strategy as the start consumption time of the data mutation strategy includes:

[0143] The data mutation policy is read from the database into the proxy server's memory, and the time when the data mutation policy is read is taken as the start time of consuming the data mutation policy.

[0144] According to one or more embodiments of this disclosure, Example 7 provides the method of Example 1 or 2, further comprising:

[0145] The crash information and the correlation between the crash information and the mutation response information are reported to the target server so that the crash information and the correlation can be obtained through the data acquisition interface of the target server to determine the cause of the test device crash.

[0146] According to one or more embodiments of this disclosure, Example 8 provides a testing apparatus, the apparatus comprising:

[0147] An acquisition module is used to acquire a data mutation strategy and use the time of acquiring the data mutation strategy as the start consumption time of the data mutation strategy. The data mutation strategy is used to modify the response information of the network request.

[0148] The first receiving module is used to receive a first network request sent by the test device, send the first network request to the server, and receive the request response information returned by the server in response to the first network request.

[0149] The first modification module is used to modify the request response information based on the data mutation strategy through the first thread, obtain the mutation response information, send the mutation response information to the test device, and set a completion status flag for the data mutation strategy.

[0150] The determination module is used to run the second thread at a preset time interval. If the completion status identifier of the data mutation policy is read when the second thread is running, the running time of the second thread is taken as the consumption success time of the data mutation policy, wherein the second thread runs in parallel with the first thread.

[0151] The association module is used to determine the timestamp of the crash information when the test device crashes, and to establish an association between the crash information and the mutation response information based on the comparison between the time represented by the timestamp and the start time and successful time of the data mutation strategy.

[0152] According to one or more embodiments of the present disclosure, Example 9 provides a non-transitory computer-readable storage medium having a computer program stored thereon that, when executed by a processing device, implements the steps of the method described in any one of Examples 1-7.

[0153] According to one or more embodiments of this disclosure, Example 10 provides an electronic device, including:

[0154] A storage device on which computer programs are stored;

[0155] A processing device for executing the computer program in the storage device to implement the steps of any one of the methods in Examples 1-7.

[0156] The above description is merely a preferred embodiment of this disclosure and an explanation of the technical principles employed. Those skilled in the art should understand that the scope of this disclosure is not limited to technical solutions formed by specific combinations of the above-described technical features, but should also cover other technical solutions formed by arbitrary combinations of the above-described technical features or their equivalents without departing from the above-described concept. For example, technical solutions formed by substituting the above features with (but not limited to) technical features disclosed in this disclosure that have similar functions.

[0157] Furthermore, while the operations are described in a specific order, this should not be construed as requiring these operations to be performed in the specific order shown or in a sequential order. In certain environments, multitasking and parallel processing may be advantageous. Similarly, while several specific implementation details are included in the above discussion, these should not be construed as limiting the scope of this disclosure. Certain features described in the context of individual embodiments may also be implemented in combination in a single embodiment. Conversely, various features described in the context of a single embodiment may also be implemented individually or in any suitable sub-combination in multiple embodiments.

[0158] Although the subject matter has been described using language specific to structural features and / or methodological logic, it should be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or actions described above. Rather, the specific features and actions described above are merely illustrative forms of implementing the claims. Regarding the apparatus in the above embodiments, the specific manner in which the various modules perform their operations has been described in detail in the embodiments relating to the method, and will not be elaborated upon here.

Claims

1. A testing method, characterized in that, The method includes: A data mutation policy is obtained, and the time when the data mutation policy is obtained is taken as the start consumption time of the data mutation policy. The data mutation policy is used to modify the response information of the network request. Receive a first network request sent by the test device, send the first network request to the server, and receive the request response information returned by the server in response to the first network request; The first thread modifies the request response information based on the data mutation strategy to obtain mutation response information, and sends the mutation response information to the test device, and sets a completion status flag for the data mutation strategy; The second thread runs at a preset time interval. If the completion status flag of the data mutation policy is read when the second thread is running, the running time of the second thread is taken as the successful consumption time of the data mutation policy. The second thread runs in parallel with the first thread. If the test device crashes, the timestamp of the crash information is determined, and the association between the crash information and the mutation response information is established based on the comparison between the time represented by the timestamp and the start time and successful time of the data mutation strategy.

2. The method according to claim 1, characterized in that, The step of establishing the association between the crash information and the mutation response information based on the comparison results between the time represented by the timestamp and the start time and successful time of the data mutation strategy includes: If the time represented by the timestamp falls between the start consumption time and the successful consumption time, establish an association between the crash information and the mutation response information; or If the time represented by the timestamp is not between the start consumption time and the consumption success time, determine whether the time represented by the timestamp is between the start consumption time of the data mutation strategy and the start consumption time of the next acquired data mutation strategy; If the time represented by the timestamp is between the start consumption time of the data mutation strategy and the start consumption time of the next acquired data mutation strategy, then an association is established between the crash information and the mutation response information.

3. The method according to claim 1 or 2, characterized in that, The method further includes: Receive a second network request sent by the test device, send the second network request to the server, and receive the request response information returned by the server in response to the second network request; The first thread modifies the request-response information of the second network request based on the data mutation strategy to obtain the reproduced mutation response information, and sends the reproduced mutation response information to the test device through the first thread. If the test device crashes, the current crash information of the test device is used as the reproduced crash information. Establishing the association between the crash information and the mutation response information includes: If the stack information of the crash information is consistent with the stack information of the reproduced crash information, then an association relationship is established between the crash information and the mutation response information.

4. The method according to claim 1 or 2, characterized in that, The data mutation strategy is used to modify target data in the response information of a network request. The value of the target data includes at least one sub-data consisting of a key name and a corresponding value. Modifying the request response information based on the data mutation strategy includes: The data mutation strategy is converted into a sub-data mutation strategy for each of the sub-data items; The request-response information of the first network request is modified according to each of the sub-data mutation strategies.

5. The method according to claim 1 or 2, characterized in that, The data mutation strategy was obtained in the following way: The system receives a third network request sent by the test device and sends the third network request to the server. It also receives a path correspondence returned by the server, which is used to characterize the correspondence between the request path of the third network request and the request response information of the third network request. The path mapping relationship is sent to the strategy generator, and the data mutation strategy sent by the strategy generator is received. The data mutation strategy is obtained by the strategy generator by associating the preset data modification rules with the request path in the path mapping relationship. Modifying the request-response information based on the data mutation strategy includes: Determine the request path of the first network request. If the request path of the first network request is the same as the request path corresponding to the data mutation strategy, modify the request response information corresponding to the first network request based on the data mutation strategy.

6. The method according to claim 1 or 2, characterized in that, The step of acquiring the data mutation strategy and using the time of acquiring the data mutation strategy as the start time of consuming the data mutation strategy includes: The data mutation policy is read from the database into the proxy server's memory, and the time when the data mutation policy is read is taken as the start time of consuming the data mutation policy.

7. The method according to claim 1 or 2, characterized in that, Also includes: The crash information and the correlation between the crash information and the mutation response information are reported to the target server so that the crash information and the correlation can be obtained through the data acquisition interface of the target server to determine the cause of the test device crash.

8. A testing device, characterized in that, The device includes: The acquisition module is used to acquire a data mutation strategy and use the time of acquiring the data mutation strategy as the start consumption time of the data mutation strategy. The data mutation strategy is used to modify the response information of the network request. The first receiving module is used to receive a first network request sent by the test device, send the first network request to the server, and receive the request response information returned by the server in response to the first network request. The first modification module is used to modify the request response information based on the data mutation strategy through the first thread, obtain the mutation response information, send the mutation response information to the test device, and set a completion status flag for the data mutation strategy. The determination module is used to run the second thread at a preset time interval. If the completion status identifier of the data mutation policy is read when the second thread is running, the running time of the second thread is taken as the consumption success time of the data mutation policy, wherein the second thread runs in parallel with the first thread. The association module is used to determine the timestamp of the crash information when the test device crashes, and to establish an association between the crash information and the mutation response information based on the comparison between the time represented by the timestamp and the start time and successful time of the data mutation strategy.

9. A non-transitory computer-readable storage medium having a computer program stored thereon, characterized in that, When executed by the processing device, the program implements the steps of the method described in any one of claims 1-7.

10. An electronic device, characterized in that, include: A storage device on which computer programs are stored; A processing device for executing the computer program in the storage device to implement the steps of the method according to any one of claims 1-7.

Images