Robustness detection method and device, computer device and storage medium

Abstract

The application relates to a robustness detection method and device, computer equipment and a storage medium, and relates to the field of software detection. The method comprises the following steps: randomly selecting a target modification mode from modification modes by a distribution algorithm based on the weights of at least two modification modes; intercepting network request data through a proxy service; modifying the network request data according to a test scene and the target modification mode; and sending the modified network request data to a test object to obtain robustness problems of the test object after the modified network request data. Through the above method, the network request data can be modified based on the test scene in the robustness detection process, so that the automation of robustness detection is realized, the test coverage is expanded, and the labor cost is reduced.

Description

Technical Field

[0001] This application relates to the field of software testing, and in particular to a robustness testing method, apparatus, computer equipment, and storage medium. Background Technology

[0002] With the rapid development of mobile applications and the increasing complexity and diversity of business models as the user base grows, both client-side and server-side applications require frequent releases to meet user demands. Given the large user base, if server-side interface upgrades or cluster failures result in data returned that does not conform to the agreed-upon format, leading to large-scale interface interaction anomalies or application crashes, it can cause irreparable and severe losses. Therefore, robustness testing of the system is essential.

[0003] In related technologies, in order to test the robustness of a system, test interface definitions are often manually entered, test data is modified and updated using a single modification rule, test cases are generated, and the test cases are input into the system to detect the system's robustness.

[0004] However, in the aforementioned related technologies, the test interface definition is defined by manual input. Due to the limitations of manual operation and the fact that modifications are based on a single rule corresponding to the type of the field, and the scenario for the same field is fixed, the test coverage is low, the degree of automation is low, and it also brings high labor costs. Summary of the Invention

[0005] This application relates to a robustness testing method, apparatus, computer equipment, and storage medium, which can automate robustness testing, expand test coverage, and reduce labor costs. The technical solution is as follows:

[0006] On the one hand, a robustness testing method is provided, the method being performed by a robustness testing device, the method comprising:

[0007] Based on the weights of at least two modification modes, a target modification mode is randomly selected from the modification modes using an allocation algorithm;

[0008] Intercept network request data corresponding to network requests through a proxy service;

[0009] Modify the network request data according to the test scenario and the target modification mode;

[0010] The modified network request data is sent to the test object to obtain the robustness of the test object after the modified network request data.

[0011] On the other hand, a robustness testing device is provided for use in a robustness testing apparatus, the device comprising:

[0012] A selection module is used to randomly select a target modification mode from the modification modes based on the weights of at least two modification modes using an allocation algorithm;

[0013] The interception module is used to intercept network request data corresponding to network requests through the proxy service;

[0014] Modify the network request data according to the test scenario and the target modification mode;

[0015] The sending module is used to send the modified network request data to the test object in order to obtain the robustness of the test object after the modified network request data.

[0016] In some embodiments, the apparatus further includes:

[0017] The adjustment module is used to adjust the weight of the modification mode based on the robustness issues exhibited by the test object and the target modification mode;

[0018] An iterative module is used to iterate the robustness detection method based on the weights of the modified modified mode.

[0019] In some embodiments, the adjustment module includes:

[0020] The acquisition submodule is used to acquire the number of robustness issues corresponding to the target modification mode;

[0021] The weighting submodule is used to increase the weight of the target modification mode in the modification mode where the number of the robustness problem is greater than a threshold.

[0022] The weight reduction submodule is used to reduce the weight of the target modification mode in the modification mode where the number of robustness problems is less than the number threshold.

[0023] In some embodiments, the modification modes include, but are not limited to, network request data status code exception mode, network request data data exception mode, and network request data data structure corruption mode.

[0024] In some embodiments, the status code exception mode of the network request data includes:

[0025] Modify the request body or response body of the network request data to null;

[0026] And, change the response code of the network request data to 404;

[0027] The abnormal data patterns of the network request data include:

[0028] Modify the Request Body or Response Body of the network request data to generate a new data structure;

[0029] The data structure of the network request data is corrupted in the following modes:

[0030] Modify the Request Body or Response Body of the network request so that the data structure of the network request data is broken into a non-iterable object.

[0031] In some embodiments, modifying the Request Body or Response Body of the network request data to generate a new data structure includes:

[0032] Recursively search all fields of the Body data structure in the network request data;

[0033] A modification operation is randomly assigned to each field using an allocation algorithm, and each field is modified to generate a new data structure from the network request data. The modification operations are pre-set and have corresponding weight proportions, and the number of modification operations is at least two.

[0034] In some embodiments, the modification operation includes, but is not limited to, setting a field to null without changing its type, deleting a field, changing the type of a field, and changing the value of a field without changing its type.

[0035] In some embodiments, the test scenarios include interface robustness testing scenarios and front-end robustness testing scenarios;

[0036] The interface robustness testing scenario refers to simulating the modification of the request data from the front end before sending it to the server.

[0037] The aforementioned front-end robustness testing scenario refers to simulating modifying the data returned by the server and then transmitting it to the front-end.

[0038] In some embodiments, the interface robustness detection scenario corresponds to a modification of the Request Body;

[0039] The corresponding changes to the Response Code and Response Body are made for the front-end robustness detection scenario.

[0040] On the other hand, a computer device is provided, the computer device including a processor and a memory, the memory storing at least one instruction, at least one program, code set or instruction set, the at least one instruction, the at least one program, the code set or instruction set being loaded and executed by the processor to implement the robustness detection method provided in the embodiments of this application.

[0041] On the other hand, a computer-readable storage medium is provided, wherein at least one instruction, at least one program, code set, or instruction set is stored in the storage medium, and the at least one instruction, at least one program, code set, or instruction set is loaded and executed by a processor to implement the robustness detection method provided in the embodiments of this application.

[0042] On the other hand, a computer program product or computer program is provided, which includes computer instructions stored in a computer-readable storage medium. A processor of a computer device reads the computer instructions from the computer-readable storage medium and executes the computer instructions, causing the computer device to perform the robustness detection methods provided in the various alternative implementations described above.

[0043] The beneficial effects of the technical solution provided in this application include at least the following:

[0044] During robustness testing, multiple modification modes are set, each with a corresponding weight. A target modification mode is randomly selected using an allocation algorithm. Based on the corresponding test scenario and the target modification mode, network request data intercepted by the proxy service is modified, and the modified network request data is sent to the test object to identify robustness issues. The weights of the various modification modes are adjusted according to the robustness issues and their corresponding modification modes, so that the random probability of the modification mode that exposes the most robustness issues is higher. This automates robustness testing, expands test coverage, and reduces labor costs. Attached Figure Description

[0045] To more clearly illustrate the technical solutions in the embodiments of this application, the accompanying drawings used in the description of the embodiments will be briefly introduced below. Obviously, the accompanying drawings described below are only some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0046] Figure 1 A flowchart illustrating a robustness detection method provided in an exemplary embodiment of this application is shown;

[0047] Figure 2A flowchart of a robustness detection method provided in an exemplary embodiment of this application is shown;

[0048] Figure 3 A schematic diagram of the structure of an electronic device provided in an exemplary embodiment of this application is shown;

[0049] Figure 4 A block diagram of a robustness detection device provided in an exemplary embodiment of this application is shown;

[0050] Figure 5 This is a structural block diagram of a computer device according to an exemplary embodiment;

[0051] Figure 6 This is a structural block diagram of a computer device according to an exemplary embodiment. Detailed Implementation

[0052] Exemplary embodiments will now be described in detail, examples of which are illustrated in the accompanying drawings. When the following description relates to the drawings, unless otherwise indicated, the same numbers in different drawings denote the same or similar elements. The embodiments described in the following exemplary embodiments do not represent all embodiments consistent with this application. Rather, they are merely examples of apparatuses and methods consistent with some aspects of this application as detailed in the appended claims.

[0053] It should be understood that "several" in this article refers to one or more, and "multiple" refers to two or more. "And / or" describes the relationship between related objects, indicating that three relationships can exist. For example, A and / or B can represent: A alone, A and B simultaneously, or B alone. The character " / " generally indicates that the preceding and following related objects have an "or" relationship.

[0054] To make the objectives, technical solutions, and advantages of this application clearer, the embodiments of this application will be described in further detail below with reference to the accompanying drawings.

[0055] First, a brief introduction to the terms used in the embodiments of this application:

[0056] 1) Robustness

[0057] Robustness refers to the ability of software to continue operating normally under abnormal conditions. Robustness can be divided into two aspects: fault tolerance and recovery capability.

[0058] System robustness is generally considered from the following aspects:

[0059] (1) Pass: The system should produce the expected normal results after inputting parameters.

[0060] (2) Catastrophic failure: This is the most serious failure in system robustness. When this failure occurs, it can only be recovered by rebooting, such as restarting the system or computer.

[0061] (3) Restart failure: The system function call does not return, causing the program that called it to suspend or stop.

[0062] (4) Abrupt failure: Abnormal input occurs during program operation, causing system errors and program termination.

[0063] (5) Silent failure: When abnormal input occurs, the system should return an error message, but no abnormal information is returned during the test.

[0064] (6) Interference failure: When the system malfunctions, an error message is returned, but it is not the expected error message, that is, the input and the result do not match.

[0065] Good robustness design requires consideration of the following aspects, which are also the aspects that need to be paid attention to during testing:

[0066] (1) Portability: Robustness testing benchmarks are used to compare the robustness of different systems, so they must support portability between multiple systems.

[0067] (2) Coverage: An ideal benchmark program should be able to cover all system modules, but this would be very costly. Therefore, during the testing process, high-priority modules are generally selected for testing, and abnormal use of modules is tested in a targeted manner.

[0068] (3) Scalability: refers to whether the current benchmark program can provide a way to ensure system upgrade or module expansion capabilities.

[0069] 2) Robustness Testing

[0070] Robustness testing, also known as fault tolerance testing, is used to test whether a system can automatically recover or ignore faults and continue operating when they occur.

[0071] The content of a robustness test may include:

[0072] (1) Kill the critical process or thread, and then observe the system behavior;

[0073] (2) Suspend critical processes or threads and then observe system behavior;

[0074] (3) If the network is down, observe the system behavior;

[0075] (4) If the database is not working, then observe the system behavior.

[0076] 3) Test Cases

[0077] A test case is a set of test inputs, execution conditions, and expected results designed for a specific purpose, to test a program path or verify whether a specific requirement is met. In simpler terms, it's describing the operational steps of a test system in a structured, written format. It scientifically organizes and summarizes software testing activities, aiming to transform these activities into manageable patterns. Test cases are also a method for quantifying testing; different types of software require different test cases. Unlike systems, tools, control systems, and games, management software exhibits increasingly diverse user needs.

[0078] 4) body

[0079] The `body` element defines the main body of a document. It contains all the document's content (such as text, hyperlinks, images, tables, lists, etc.). The `body` tag is an HTML tag used in web pages to represent the main body of the page, which is the content the user can see. It can contain various content such as text, images, audio, and video.

[0080] Mobile applications are developing rapidly, and business models are becoming increasingly complex and diverse with user growth. Applications have a large user base and numerous business scenarios, requiring frequent client and server releases to meet user demands. With such a large user base, if server-side interface upgrades or cluster failures result in data returned that does not conform to the agreed-upon format, leading to large-scale interface interaction anomalies or application crashes, it can cause irreparable and severe losses. Therefore, robustness testing of the system is essential.

[0081] In related technologies, in order to test the robustness of a system, test interface definitions are often manually entered, test data is modified and updated using a single modification rule, test cases are generated, and the test cases are input into the system to detect the system's robustness.

[0082] In the aforementioned technologies, manually inputting test interface definitions leads to low test coverage and low automation due to limitations of manual operation. Furthermore, modifications are based on a single rule corresponding to the type of the field, and the scenario for the same field is fixed. This also results in high labor costs.

[0083] To address the problems in the aforementioned related technologies, this application provides a robustness testing method that can automate robustness testing, expand test coverage, and reduce labor costs. Please refer to... Figure 1 It illustrates a flowchart of a robustness testing method provided in an exemplary embodiment of this application, which can be performed by a robustness testing device, such as... Figure 1 As shown, the method may include:

[0084] Step 110: Based on the weights of at least two modification modes, a target modification mode is randomly selected from the modification modes using an allocation algorithm.

[0085] The modification mode is predefined, has a corresponding weight percentage, and there are at least two such modification modes.

[0086] In some embodiments, the weight of the modification mode is not fixed. The weight ratio of the modification mode can be dynamically adjusted based on the frequency of the modification mode's operation and the frequency of the modification mode discovering robustness problems in robustness detection, so as to change the probability that the modification mode is randomly selected as the target modification mode under the action of the allocation algorithm.

[0087] Step 120: Intercept the network request data corresponding to the network request through the proxy service;

[0088] Network request data is the data corresponding to a network request. A network request can be user request data sent by an application to a server based on user actions, or network data sent by a server back to an application based on a user request sent by the application.

[0089] In this context, a proxy service, or proxy server, can be a piece of software that runs on a computer. When a computer using a proxy server exchanges information with the Internet, it first sends the information to the proxy server, which then forwards it and sends the received response back to the computer.

[0090] In some embodiments, the proxy service can be Fiddler, which is used to record and inspect HTTP communications between the computer and the Internet, set breakpoints, view all data "entering" and "leaving" Fiddler, and modify this data.

[0091] Step 130: Modify the network request data according to the test scenario and target modification mode.

[0092] In some embodiments, different test scenarios correspond to different modification objects in the same modification mode. That is, in the embodiments of this application, test cases corresponding to different test scenarios can be generated to detect the robustness of the system in the test scenario.

[0093] Test scenarios correspond to actual business scenarios. A business scenario is a business situation triggered by different events in a business process. For example, in a bank withdrawal process, the final withdrawal result and process branches will differ due to various factors such as the user's identity (VIP or not), the withdrawal amount (large or small), and the card balance (fully withdrawn or insufficient). A test scenario is a quality-oriented description of the business situation when such events are triggered. Test cases, on the other hand, provide detailed coverage of the test scenario in terms of test scope and test points.

[0094] Step 140: Send the modified network request data to the test object to obtain the robustness of the test object after the modified network request data.

[0095] After receiving the modified network request data, the test object will perform corresponding data processing or page rendering based on the modified network request data. For the application, when it receives the network request data sent by the server modified by the robustness detection device, it will display the page based on the modified network request data, that is, the abnormal network request data, to provide feedback to the user. In this process, the page rendered and displayed under the abnormal network request data can be compared with the page rendered and displayed under the normal network request data to discover robustness issues under the abnormal network request.

[0096] In summary, the robustness detection method provided in this application sets multiple modification modes during robustness detection, and each modification mode is assigned a corresponding weight. A target modification mode is randomly selected through an allocation algorithm. The network request data intercepted by the proxy service is modified according to the corresponding test scenario and the target modification mode. The modified network request data is then sent to the test object to obtain the robustness issues corresponding to the test object. Since the network data is modified based on the test scenario during the robustness detection process, the robustness detection can be automated, the test coverage can be expanded, and the labor costs can be reduced.

[0097] In some embodiments, the test scenarios include interface robustness testing scenarios and front-end robustness testing scenarios. The robustness testing method described in this application will be explained below using the example of test scenarios including interface robustness testing scenarios and front-end robustness testing scenarios. Please refer to [link / reference]. Figure 2 It illustrates a flowchart of a robustness testing method provided in an exemplary embodiment of this application, which can be performed by a robustness testing device, such as... Figure 2 As shown, the method may include:

[0098] Step 210: Based on the weights of at least two modification modes, a target modification mode is randomly selected from the modification modes using an allocation algorithm.

[0099] In some embodiments, the modification mode includes, but is not limited to, an error code for the network request data, a change body for the network request data, or a corrupted data structure for the network request data.

[0100] Among them, the error codes for network request data include:

[0101] Modify the Request Body or Response Body of the network request data to null.

[0102] Also, change the Response Code of the network request data to 404.

[0103] Data errors in network request data (Change Body) include:

[0104] Modify the Request Body or Response Body of the network request data to generate a new data structure.

[0105] The data structure of the network request data was corrupted (Broken Body), including:

[0106] Modify the Request Body or Response Body of a network request so that the data structure of the network request data is broken into a non-iterable object.

[0107] In some embodiments, the attributes of each field in the network request data are defined in the data information, such as the field name, required attributes (whether the field is required), length, data type, and whether nullables are allowed.

[0108] Based on the above attribute definitions for each field in the data information, in some embodiments, the modification of the Request Body or Response Body of the network request data to generate a new data structure can be manifested as follows:

[0109] Recursively search all fields of the Body data structure in the network request data;

[0110] Each field is randomly assigned a modification operation through an allocation algorithm. Each field is modified to generate a new data structure from the network request data. The modification operation is pre-set and has a corresponding weight. The number of modification operations is at least two.

[0111] In some embodiments, modification operations include, but are not limited to, emptying a field without changing its type (Empty), deleting a field (Del), changing the type of a field (Change Type), and changing the value of a field without changing its type (Change Value).

[0112] In some embodiments, the weights of predetermined modification operations in the network request data anomaly pattern can be adjusted based on the robustness detection results of the system. After multiple iterations, the modification operations that expose more problems will have a higher probability of being performed randomly in the network request data anomaly pattern, i.e., a higher weight.

[0113] In some embodiments, the process of randomly selecting a target modification mode from modification modes using an allocation algorithm can be implemented as follows:

[0114] Sum the weights of all modification patterns, and randomly select a number from 0 to the sum of the weights. Then, repeat the following steps: randomly select a modification pattern from the list of modification patterns, compare the random number with its weight, and if the random number is smaller, exit the loop and take that modification pattern as the result; if the random number is larger, select another modification pattern from the remaining list, add its weight to the weight of the previously selected modification pattern, and compare the accumulated value with the random number. Continue until the accumulated value is greater than the random number, and then take the last selected modification pattern as the result.

[0115] For example, if the sum of the weights of all modification patterns is 1, then a number is randomly selected from the range of 0 to 1, let's say it's 0.4. A modification pattern is randomly selected from the modification pattern list, and the random number is compared with its weight. Let's say the weight of this modification pattern is 0.5. Since 0.5 is greater than 0.4, the loop is exited, and this modification pattern is taken as the target modification pattern. However, if the weight of this modification pattern is 0.2, since 0.2 is less than 0.4, another modification pattern is randomly selected from the remaining modification pattern list. The weight of this modification pattern is added to the weight of the previously selected modification pattern, and the added value is compared with the random number. Let's say the weight of the modification pattern randomly selected from the remaining modification patterns is 0.3. Since the sum of the weights of the first and second selected modification patterns is 0.5, which is greater than 0.4, the loop is exited, and the second selected modification pattern is taken as the target modification pattern.

[0116] Step 220: Intercept the network request data corresponding to the network request through the proxy service.

[0117] In this application embodiment, the robustness detection scenario includes a front-end robustness detection scenario and an interface robustness detection scenario.

[0118] Among them, the interface robustness test scenario refers to simulating the modification of the request data from the front end and sending it to the server;

[0119] Front-end robustness testing scenarios refer to simulating modifying data returned by the server and then sending it to the front-end.

[0120] When the test scenario is an interface robustness test scenario, when a network request is triggered, the robustness test device simulates the front end to send the modified network request data to the server, and the server is the test object accordingly.

[0121] When the test scenario is a front-end robustness test scenario, when a network request is triggered, the robustness test device simulates a server to send the modified network request data to the front end, and the front end is the test object.

[0122] The front-end, or website front-end, refers to the web pages displayed to users on browsers such as PCs (Personal Computers) and mobile devices. The PC and mobile devices can be electronic devices, such as smartphones, tablets, e-readers, smartwatches, or fixed terminals like all-in-one computers. Please refer to [reference needed]. Figure 3 This illustrates a schematic diagram of the structure of an electronic device provided in an exemplary embodiment of this application. For example... Figure 3 As shown, the electronic device includes a motherboard 310, an external output / input device 320, a memory 330, an external interface 340, a touch system 350, and a power supply 360.

[0123] The motherboard 310 integrates processing components such as a processor and a controller.

[0124] External output / input device 320 may include display components (such as a display screen), sound playback components (such as a speaker), sound acquisition components (such as a microphone), and various buttons, etc.

[0125] The memory 330 stores program code and data.

[0126] External interfaces 340 may include headphone jacks, charging ports, and data ports.

[0127] The touch system 350 can be integrated into the display component or buttons of the external output / input device 320. The touch system 350 is used to detect touch operations performed by the user on the display component or buttons.

[0128] Power Supply 360 is used to power the other components in the terminal.

[0129] Step 230: In response to the fact that the test scenario is a front-end robustness test scenario, modify the Response Code and Response Body of the network request data according to the target modification mode.

[0130] Step 240: In response to the test scenario being an interface robustness detection scenario, modify the Request Body according to the target modification mode.

[0131] The objects to be modified differ between front-end robustness testing and API robustness testing. Front-end robustness testing involves modifying the Response Code and Response Body of network request data, while API robustness testing involves modifying the Request Body of network request data.

[0132] In other words, corresponding to the three modification modes mentioned above, in the interface robustness detection scenario, for the network request data status code exception mode, the main modification is to change the Request Body of the network request to null; for the network request data data exception mode, the main modification is to change the Request Body of the network request data to generate a new data structure; for the network request data data structure corruption mode, the main modification is to change the Request Body of the network request data to corrupt the data structure into a non-iterative object.

[0133] In front-end robustness testing scenarios, for network request data status code exception modes, the main modification is to change the network request's Response Body to null and the Response Code to 404; for network request data data exception modes, the main modification is to change the network request's Response Body to generate a new data structure; for network request data data data data structure corruption modes, the main modification is to change the network request's Response Body to corrupt the network request's data structure into a non-iterative object.

[0134] Step 250: Send the modified network request data to the test object to obtain the robustness of the test object's performance after the modified network request data.

[0135] Optionally, for interface robustness testing scenarios, robustness issues are reflected in the difference between the server's response to modified request data sent by the front end (i.e., abnormal data) and the server's response to the abnormal data, compared with the server's response to unmodified request data sent by the front end (i.e., normal data).

[0136] In front-end robustness testing scenarios, robustness issues are reflected in the front-end's behavior after receiving modified data returned from the server, such as application crashes or page loading errors.

[0137] Step 260: Adjust the weight of the modification mode based on the robustness issues of the test object's performance and the target modification mode.

[0138] In some embodiments, the above steps can be implemented as follows:

[0139] Step 2601: Obtain the number of robustness issues corresponding to the target modification mode.

[0140] Step 2602: Increase the weight of target modification patterns whose number of corresponding robustness issues exceeds a threshold.

[0141] Step 2603: Reduce the weight of target modification patterns whose number of corresponding robustness issues is less than a threshold.

[0142] In some embodiments, the sum of the weights of at least two preset modification modes in the robustness testing device is a fixed value. After robustness testing, the weights of at least two modification modes in the robustness testing device can be adjusted according to the number of robustness problems of the test object exposed in each modification mode.

[0143] In some embodiments, a quantity threshold can be preset to increase the weight of detection modes that expose more problems in the test object than the quantity threshold, and decrease the weight of test modes that expose less problems in the test object than the quantity threshold, so that the probability of detection modes that expose more problems is increased under the action of the allocation algorithm.

[0144] In some embodiments, modification modes can be sorted according to the number of robustness issues corresponding to the modification mode, and the weight ratio of each modification mode can be adjusted according to the robustness issues corresponding to the modification mode from high to low. For example, weight rules can be preset to specify the relationship between the weight of the modification mode and the number of corresponding robustness issues. Assuming there are three modification modes, the weight of the modification mode with the most corresponding robustness issues can be set to 60%, the weight of the modification mode with the fewest corresponding robustness issues can be set to 30%, and the weight of the modification mode with a medium number of corresponding robustness issues can be set to 10%.

[0145] In some embodiments, robustness testing of the same test scenario is performed at least twice. During robustness testing, based on the number of robustness issues exposed by different modification modes, the modification mode that exposes more robustness issues for the test scenario can be selected. This allows for adjustment of the weight of the modification mode in that scenario, increasing the weight of the modification mode that exposes more robustness issues and decreasing the weight of the modification mode that exposes fewer robustness issues. This increases the probability of randomly selecting the modification mode that exposes more robustness issues when the allocation algorithm randomly selects the target modification mode.

[0146] In some embodiments, the weights of preset modification modes in the robustness testing device are adjusted according to the number of robustness issues in the current run and their corresponding modification modes. After multiple iterations, the random probability of modification modes that expose more issues is higher, i.e., their weights are greater.

[0147] Step 270: Iterate the robustness detection method based on the weights of the modified modification patterns.

[0148] During system testing, the testing content is continuously carried out. The modification mode selected for each robustness test is random. In some test modes, the parameter modifications can also be random, so as to detect the robustness of the system from various scenarios and aspects. Furthermore, during the robustness testing process, for different testing scenarios, the weight configuration of each mode is continuously optimized through each test, so that the random probability of the modification mode that exposes more problems is higher.

[0149] In some embodiments, the robustness testing process includes steps 210 to 250. That is, during the robustness testing process, as each test is performed, the weights of each modification mode in the robustness testing device under the testing scenario are adjusted and optimized based on the modification mode corresponding to this test and the number of robustness issues exposed, combined with the test results of the previous tests, and the optimized modification mode weights are applied to the next test.

[0150] In some embodiments, the optimized modified mode weights described above can be applied to other test scenarios of the same type.

[0151] In summary, the robustness detection method provided in this application sets multiple modification modes during robustness detection, and each modification mode is assigned a corresponding weight. A target modification mode is randomly selected through an allocation algorithm. The network request data intercepted by the proxy service is modified according to the corresponding test scenario and the target modification mode. The modified network request data is then sent to the test object to obtain the robustness issues corresponding to the test object. The weights of the multiple modification modes are adjusted according to the robustness issues and the corresponding modification modes, so that the random probability of the modification mode that exposes the most robustness issues is higher. At the same time, the network data is modified based on the test scenario, thereby automating robustness detection, expanding test coverage, and reducing labor costs.

[0152] Please refer to Figure 4 The diagram illustrates a block diagram of a robustness testing apparatus provided in an exemplary embodiment of this application. This apparatus can be implemented in software as all or part of a robustness testing device to perform... Figure 1 or Figure 2 All or part of the steps of the method shown in the corresponding embodiments. For example... Figure 4 As shown, the robustness testing device may include:

[0153] The selection module 410 is used to randomly select a target modification mode from the modification modes based on the weights of at least two modification modes using an allocation algorithm;

[0154] Interception module 420 is used to intercept network request data corresponding to network requests through proxy service;

[0155] Modify module 430 to modify the network request data according to the test scenario and target modification mode;

[0156] The sending module 440 is used to send the modified network request data to the test object in order to obtain the robustness of the test object after the modified network request data.

[0157] In some embodiments, the device further includes:

[0158] The adjustment module is used to adjust the weight of modification patterns based on the robustness issues of the test object's performance and the target modification patterns;

[0159] The iteration module is used to iterate the robustness detection method based on the weights of the modified modification pattern.

[0160] In some embodiments, the adjustment module includes:

[0161] The acquisition submodule is used to acquire the number of robustness issues corresponding to the target modification mode;

[0162] The weighting submodule is used to increase the weight of target modification patterns whose number of corresponding robustness issues exceeds a threshold.

[0163] The weight reduction submodule is used to reduce the weight of target modification patterns where the number of corresponding robustness issues is less than a threshold.

[0164] In some embodiments, the modification mode includes, but is not limited to, a network request data status code exception mode, a network request data data exception mode, and a network request data data structure corruption mode.

[0165] In some embodiments, the status code exception modes for network request data include:

[0166] Modify the Request Body or Response Body of the network request data to null;

[0167] Also, change the Response Code of the network request data to 404;

[0168] Abnormal data patterns in network request data include:

[0169] Modify the Request Body or Response Body of the network request data to generate a new data structure;

[0170] Data structure corruption patterns in network request data include:

[0171] Modify the Request Body or Response Body of a network request so that the data structure of the network request data is broken into a non-iterable object.

[0172] In some embodiments, the Request Body or Response Body of the network request data is modified to generate a new data structure, including:

[0173] Recursively search all fields of the Body data structure in the network request data;

[0174] Each field is randomly assigned a modification operation through an allocation algorithm. Each field is modified to generate a new data structure from the network request data. The modification operations are pre-set and have corresponding weight proportions. The number of modification operations is at least two.

[0175] In some embodiments, modification operations include, but are not limited to, setting a field to null without changing its type, deleting a field, changing the type of a field, and changing the value of a field without changing its type.

[0176] In some embodiments, the test scenarios include interface robustness testing scenarios and front-end robustness testing scenarios;

[0177] Among them, the interface robustness testing scenario refers to simulating the modification of the request data from the front end and sending it to the server;

[0178] Front-end robustness testing scenarios refer to simulating modifying data returned by the server and then sending it to the front-end.

[0179] In some embodiments, the Request Body is modified accordingly for interface robustness detection scenarios;

[0180] For front-end robustness testing scenarios, modify the Response Code and Response Body accordingly.

[0181] In summary, the robustness testing device provided in this application embodiment, applied in a robustness testing device, sets multiple modification modes during robustness testing, with each modification mode having a corresponding weight. A target modification mode is randomly selected through an allocation algorithm. Based on the corresponding test scenario and the target modification mode, network request data intercepted by the proxy service is modified, and the modified network request data is sent to the test object to identify robustness issues. The weights of the multiple modification modes are adjusted according to the robustness issues and the corresponding modification modes, resulting in a higher probability of the modification mode that exposes the most robustness issues being randomly selected. Simultaneously, network data modification based on the test scenario automates robustness testing, expands test coverage, and reduces labor costs.

[0182] Figure 5 This is a structural block diagram of a computer device according to an exemplary embodiment. The computer device 500 can be implemented as a robustness testing device as described above. The computer device 500 includes a Central Processing Unit (CPU) 501, a system memory 504 including Random Access Memory (RAM) 502 and Read-Only Memory (ROM) 503, and a system bus 505 connecting the system memory 504 and the CPU 501. The computer device 500 also includes a basic input / output system (I / O system) 506 that facilitates information transfer between various devices within the computer, and a mass storage device 505 for storing the operating system 513, application programs 514, and other program modules 515.

[0183] The basic input / output system 506 includes a display 508 for displaying information and an input device 509 for user input, such as a mouse or keyboard. Both the display 508 and the input device 509 are connected to the central processing unit 501 via an input / output controller 510 connected to the system bus 505. The basic input / output system 506 may also include the input / output controller 510 for receiving and processing input from multiple other devices such as a keyboard, mouse, or electronic stylus. Similarly, the input / output controller 510 also provides output to a display screen, printer, or other types of output devices.

[0184] The mass storage device 505 is connected to the central processing unit 501 via a mass storage controller (not shown) connected to the system bus 505. The mass storage device 505 and its associated computer-readable media provide non-volatile storage for the computer device 500. That is, the mass storage device 505 may include computer-readable media (not shown) such as a hard disk or a compact disc read-only memory (CD-ROM) drive.

[0185] Without loss of generality, the computer-readable medium may include computer storage media and communication media. Computer storage media include volatile and non-volatile, removable and non-removable media implemented using any method or technology for storing information such as computer-readable instructions, data structures, program modules, or other data. Computer storage media include RAM, ROM, erasable programmable read-only memory (EPROM), electrically erasable programmable read-only memory (EEPROM), flash memory or other solid-state storage technologies, CD-ROM, digital versatile disc (DVD) or other optical storage, magnetic tape cassettes, magnetic tape, disk storage, or other magnetic storage devices. Of course, those skilled in the art will recognize that the computer storage media are not limited to the above-mentioned types. The system memory 504 and mass storage device 505 described above can be collectively referred to as memory.

[0186] According to various embodiments of this application, the computer device 500 can also be connected to a remote computer on a network, such as the Internet. That is, the computer device 500 can be connected to a network 512 via a network interface unit 511 connected to the system bus 505, or the network interface unit 511 can be used to connect to other types of networks or remote computer systems (not shown).

[0187] The memory also includes one or more programs, which are stored in the memory, and the central processing unit 501 implements these programs by executing them. Figure 1 or Figure 2 All or part of the steps of the method shown.

[0188] Those skilled in the art will understand that the functions described in the embodiments of this application in one or more of the above examples can be implemented using hardware, software, firmware, or any combination thereof. When implemented using software, these functions can be stored in a computer-readable medium or transmitted as one or more instructions or code on a computer-readable medium. Computer-readable media include computer storage media and communication media, wherein communication media include any medium that facilitates the transmission of a computer program from one place to another. Storage media can be any available medium that can be accessed by a general-purpose or special-purpose computer.

[0189] Figure 6 This is a structural block diagram of a computer device 600 according to an exemplary embodiment. The computer device 600 may be... Figure 3 The electronic device shown is such as a smartphone, tablet, or desktop computer. Computer device 600 may also be referred to as user equipment, portable terminal, laptop terminal, desktop terminal, or other names.

[0190] Typically, computer device 600 includes a processor 601 and a memory 602.

[0191] Processor 601 may include one or more processing cores, such as a quad-core processor, an octa-core processor, etc. Processor 601 may be implemented using at least one hardware form selected from DSP (Digital Signal Processing), FPGA (Field-Programmable Gate Array), and PLA (Programmable Logic Array). Processor 601 may also include a main processor and a coprocessor. The main processor, also known as a CPU (Central Processing Unit), is used to process data in the wake-up state; the coprocessor is a low-power processor used to process data in the standby state. In some embodiments, processor 601 may integrate a GPU (Graphics Processing Unit), which is responsible for rendering and drawing the content to be displayed on the screen. In some embodiments, processor 601 may also include an AI (Artificial Intelligence) processor, which is used to handle computational operations related to machine learning.

[0192] Memory 602 may include one or more computer-readable storage media, which may be non-transitory. Memory 602 may also include high-speed random access memory and non-volatile memory, such as one or more disk storage devices or flash memory devices. In some embodiments, the non-transitory computer-readable storage media in memory 602 are used to store at least one instruction, which is executed by processor 601 to implement the method provided in the method embodiments of this application.

[0193] In some embodiments, the computer device 600 may optionally include a peripheral device interface 603 and at least one peripheral device. The processor 601, memory 602, and peripheral device interface 603 can be connected via a bus or signal line. Each peripheral device can be connected to the peripheral device interface 603 via a bus, signal line, or circuit board. Specifically, the peripheral device includes at least one of the following: a radio frequency circuit 604, a touch display screen 605, a camera 606, an audio circuit 607, a positioning component 608, and a power supply 609.

[0194] Peripheral interface 603 can be used to connect at least one I / O (Input / Output) related peripheral device to processor 601 and memory 602. In some embodiments, processor 601, memory 602 and peripheral interface 603 are integrated on the same chip or circuit board; in some other embodiments, any one or two of processor 601, memory 602 and peripheral interface 603 can be implemented on separate chips or circuit boards, which is not limited in this embodiment.

[0195] The radio frequency (RF) circuit 604 is used to receive and transmit RF (Radio Frequency) signals, also known as electromagnetic signals. The RF circuit 604 communicates with communication networks and other communication devices via electromagnetic signals. The RF circuit 604 converts electrical signals into electromagnetic signals for transmission, or converts received electromagnetic signals back into electrical signals. Optionally, the RF circuit 604 includes: an antenna system, an RF transceiver, one or more amplifiers, a tuner, an oscillator, a digital signal processor, a codec chipset, a user identity module card, etc. The RF circuit 604 can communicate with other terminals through at least one wireless communication protocol. This wireless communication protocol includes, but is not limited to: the World Wide Web, metropolitan area networks, intranets, various generations of mobile communication networks (2G, 3G, 4G, and 5G), wireless local area networks, and / or WiFi (Wireless Fidelity) networks. In some embodiments, the RF circuit 604 may also include circuitry related to NFC (Near Field Communication), which is not limited in this application.

[0196] Display screen 605 is used to display a UI (User Interface). This UI may include graphics, text, icons, videos, and any combination thereof. When display screen 605 is a touch display screen, it also has the ability to collect touch signals on or above its surface. These touch signals can be input as control signals to processor 601 for processing. In this case, display screen 605 can also be used to provide virtual buttons and / or a virtual keyboard, also known as soft buttons and / or a soft keyboard. In some embodiments, there may be one display screen 605, which is located on the front panel of the computer device 600; in other embodiments, there may be at least two display screens, respectively located on different surfaces of the computer device 600 or in a folded design; in still other embodiments, display screen 605 may be a flexible display screen, located on a curved or folded surface of the computer device 600. Furthermore, display screen 605 may be configured as a non-rectangular irregular shape, i.e., a non-rectangular screen. Display screen 605 may be made of materials such as LCD (Liquid Crystal Display) or OLED (Organic Light-Emitting Diode).

[0197] The camera assembly 606 is used to acquire images or videos. Optionally, the camera assembly 606 includes a front-facing camera and a rear-facing camera. Typically, the front-facing camera is located on the front panel of the terminal, and the rear-facing camera is located on the back of the terminal. In some embodiments, there are at least two rear-facing cameras, which are any one of a main camera, a depth-sensing camera, a wide-angle camera, and a telephoto camera, to achieve background blurring by fusion of the main camera and the depth-sensing camera, panoramic shooting by fusion of the main camera and the wide-angle camera, VR (Virtual Reality) shooting, or other fusion shooting functions. In some embodiments, the camera assembly 606 may also include a flash. The flash can be a single-color temperature flash or a dual-color temperature flash. A dual-color temperature flash refers to a combination of a warm light flash and a cool light flash, which can be used for light compensation at different color temperatures.

[0198] The audio circuit 607 may include a microphone and a speaker. The microphone is used to collect sound waves from the user and the environment, converting them into electrical signals that are input to the processor 601 for processing, or to the radio frequency circuit 604 for voice communication. For stereo sound acquisition or noise reduction purposes, multiple microphones may be used, each positioned at a different location within the computer device 600. The microphone may also be an array microphone or an omnidirectional microphone. The speaker is used to convert electrical signals from the processor 601 or the radio frequency circuit 604 into sound waves. The speaker may be a conventional diaphragm speaker or a piezoelectric ceramic speaker. When the speaker is a piezoelectric ceramic speaker, it can convert electrical signals not only into audible sound waves but also into inaudible sound waves for purposes such as distance measurement. In some embodiments, the audio circuit 607 may also include a headphone jack.

[0199] The positioning component 608 is used to locate the current geographical location of the computer device 600 in order to enable navigation or LBS (Location Based Service). The positioning component 608 can be a positioning component based on the US GPS (Global Positioning System), China's BeiDou system, or Russia's Galileo system.

[0200] Power supply 609 is used to supply power to the various components in computer device 600. Power supply 609 can be alternating current, direct current, a disposable battery, or a rechargeable battery. When power supply 609 includes a rechargeable battery, the rechargeable battery can be a wired rechargeable battery or a wireless rechargeable battery. A wired rechargeable battery is a battery that is charged via a wired line, while a wireless rechargeable battery is a battery that is charged via a wireless coil. The rechargeable battery can also be used to support fast charging technology.

[0201] In some embodiments, the computer device 600 further includes one or more sensors 610. The one or more sensors 610 include, but are not limited to: an accelerometer 611, a gyroscope 612, a pressure sensor 613, a fingerprint sensor 614, an optical sensor 615, and a proximity sensor 616.

[0202] Accelerometer 611 can detect the magnitude of acceleration along the three coordinate axes of a coordinate system established by computer device 600. For example, accelerometer 611 can be used to detect the components of gravitational acceleration along the three coordinate axes. Processor 601 can control touchscreen display 605 to display the user interface in landscape or portrait view based on the gravitational acceleration signal acquired by accelerometer 611. Accelerometer 611 can also be used for games or for acquiring user motion data.

[0203] The gyroscope sensor 612 can detect the orientation and rotation angle of the computer device 600. The gyroscope sensor 612, in conjunction with the accelerometer sensor 611, can collect 3D motion data from the user on the computer device 600. Based on the data collected by the gyroscope sensor 612, the processor 601 can perform the following functions: motion sensing (e.g., changing the UI based on the user's tilt), image stabilization during shooting, game control, and inertial navigation.

[0204] The pressure sensor 613 can be disposed on the side bezel of the computer device 600 and / or on the lower layer of the touch display screen 605. When the pressure sensor 613 is disposed on the side bezel of the computer device 600, it can detect the user's grip signal on the computer device 600, and the processor 601 can perform left / right hand recognition or quick operation based on the grip signal collected by the pressure sensor 613. When the pressure sensor 613 is disposed on the lower layer of the touch display screen 605, the processor 601 can control the operable controls on the UI interface based on the user's pressure operation on the touch display screen 605. The operable controls include at least one of button controls, scroll bar controls, icon controls, and menu controls.

[0205] The fingerprint sensor 614 is used to collect a user's fingerprint. The processor 601 identifies the user based on the fingerprint collected by the fingerprint sensor 614, or vice versa. When the user's identity is verified as trusted, the processor 601 authorizes the user to perform relevant sensitive operations, including unlocking the screen, viewing encrypted information, downloading software, making payments, and changing settings. The fingerprint sensor 614 can be located on the front, back, or side of the computer device 600. When the computer device 600 has physical buttons or a manufacturer's logo, the fingerprint sensor 614 can be integrated with the physical buttons or the manufacturer's logo.

[0206] An optical sensor 615 is used to collect ambient light intensity. In one embodiment, the processor 601 can control the display brightness of the touch screen 605 based on the ambient light intensity collected by the optical sensor 615. Specifically, when the ambient light intensity is high, the display brightness of the touch screen 605 is increased; when the ambient light intensity is low, the display brightness of the touch screen 605 is decreased. In another embodiment, the processor 601 can also dynamically adjust the shooting parameters of the camera assembly 606 based on the ambient light intensity collected by the optical sensor 615.

[0207] A proximity sensor 616, also known as a distance sensor, is typically mounted on the front panel of a computer device 600. The proximity sensor 616 is used to detect the distance between the user and the front of the computer device 600. In one embodiment, when the proximity sensor 616 detects that the distance between the user and the front of the computer device 600 is gradually decreasing, the processor 601 controls the touchscreen display 605 to switch from a screen-on state to a screen-off state; when the proximity sensor 616 detects that the distance between the user and the front of the computer device 600 is gradually increasing, the processor 601 controls the touchscreen display 605 to switch from a screen-off state to a screen-on state.

[0208] Those skilled in the art will understand that Figure 6 The structure shown does not constitute a limitation on the computer device 600, and may include more or fewer components than shown, or combine certain components, or use different component arrangements.

[0209] Those skilled in the art will understand that the functions described in the embodiments of this application in one or more of the above examples can be implemented using hardware, software, firmware, or any combination thereof. When implemented using software, these functions can be stored in a computer-readable medium or transmitted as one or more instructions or code on a computer-readable medium. Computer-readable media include computer storage media and communication media, wherein communication media include any medium that facilitates the transmission of a computer program from one place to another. Storage media can be any available medium that can be accessed by a general-purpose or special-purpose computer.

[0210] This application also provides a computer-readable storage medium for storing at least one instruction, at least one program, code set, or instruction set, wherein the at least one instruction, at least one program, code set, or instruction set is loaded and executed by a processor to implement the robustness detection method described above. For example, the computer-readable storage medium may be ROM, RAM, CD-ROM, magnetic tape, floppy disk, or optical data storage device, etc.

[0211] This application also provides a computer program product or computer program that includes computer instructions stored in a computer-readable storage medium. A processor of a computer device reads the computer instructions from the computer-readable storage medium and executes the computer instructions, causing the computer device to perform all or part of the steps of the robustness detection method described above.

[0212] Other embodiments of this application will readily occur to those skilled in the art upon consideration of the specification and practice of the invention disclosed herein. This application is intended to cover any variations, uses, or adaptations of this application that follow the general principles of this application and include common knowledge or customary techniques in the art not disclosed herein. The specification and examples are to be considered exemplary only, and the true scope and spirit of this application are indicated by the following claims.

[0213] It should be understood that this application is not limited to the precise structure described above and shown in the accompanying drawings, and various modifications and changes can be made without departing from its scope. The scope of this application is limited only by the appended claims.

Claims

1. A robustness detection method, characterized in that, The method is performed by a robustness testing device, and the method includes: Based on the weights of at least two modification modes, a target modification mode is randomly selected from the modification modes using an allocation algorithm, including: Sum the weight values ​​of the at least two modification modes, randomly select a number in the range from 0 to the sum of the weights, compare the random number with the weight of the modification mode, and select the target modification mode based on the comparison result. Intercept network request data corresponding to network requests through a proxy service; Modify the network request data according to the test scenario and the target modification mode; The modified network request data is sent to the test object to obtain the robustness of the test object after the modified network request data.

2. The method according to claim 1, characterized in that, The method further includes: Based on the robustness issues exhibited by the test object and the target modification pattern, the weight of the modification pattern is adjusted; The robustness detection method is iterated based on the weights of the modified modified mode.

3. The method according to claim 2, characterized in that, The adjustment of the weight of the modification mode based on the robustness issues based on the performance of the test object and the target modification mode includes: Obtain the number of robustness issues corresponding to the target modification pattern; Increase the weight of the target modification pattern whose number of robustness issues exceeds a threshold in the modification pattern; The weight of the target modification pattern whose number of robustness issues is less than the number threshold is reduced.

4. The method according to claim 1, characterized in that, The modification modes include, but are not limited to, abnormal status code mode for network request data, abnormal data mode for network request data, and corrupted data structure mode for network request data.

5. The method according to claim 4, characterized in that, The abnormal status code modes for the network request data include: Modify the request body or response body of the network request data to null; And, change the response code of the network request data to 404; The abnormal data patterns of the network request data include: Modify the Request Body or Response Body of the network request data to generate a new data structure; The data structure of the network request data is corrupted in the following modes: Modify the Request Body or Response Body of the network request so that the data structure of the network request data is broken into a non-iterable object.

6. The method according to claim 5, characterized in that, Modifying the RequestBody or Response Body of the network request data to generate a new data structure includes: Recursively search all fields of the Body data structure in the network request data; A modification operation is randomly assigned to each field using an allocation algorithm, and each field is modified to generate a new data structure from the network request data. The modification operations are pre-set and have corresponding weight proportions, and the number of modification operations is at least two.

7. The method according to claim 6, characterized in that, The modification operations include, but are not limited to, setting a field to null without changing its type, deleting a field, changing the type of a field, and changing the value of a field without changing its type.

8. The method according to claim 1, characterized in that, The test scenarios include interface robustness testing scenarios and front-end robustness testing scenarios; The interface robustness testing scenario refers to simulating the modification of the request data from the front end before sending it to the server. The aforementioned front-end robustness testing scenario refers to simulating the modification of data returned by the server and then transmitting it to the front-end.

9. The method according to claim 8, characterized in that, The corresponding modification to the Request Body is required for the interface robustness detection scenario. The corresponding changes to the Response Code and Response Body are made for the front-end robustness detection scenario.

10. A robustness detection device, characterized in that, The device is used in a robustness testing device, and the device includes: A selection module is configured to randomly select a target modification mode from the modification modes based on the weights of at least two modification modes using an allocation algorithm, including: Sum the weight values ​​of the at least two modification modes, randomly select a number in the range from 0 to the sum of the weights, compare the random number with the weight of the modification mode, and select the target modification mode based on the comparison result. The interception module is used to intercept network request data corresponding to network requests through the proxy service; The modification module modifies the network request data according to the test scenario and the target modification mode; The sending module is used to send the modified network request data to the test object in order to obtain the robustness of the test object after the modified network request data.

11. A computer device, characterized in that, The computer device includes a processor and a memory, the memory storing at least one instruction, at least one program, a code set, or an instruction set, the at least one instruction, the at least one program, the code set, or the instruction set being loaded and executed by the processor to implement the robustness detection method as described in any one of claims 1 to 9.

12. A computer-readable storage medium, characterized in that, The readable storage medium stores at least one instruction, at least one program, code set, or instruction set, wherein the at least one instruction, at least one program, code set, or instruction set is loaded and executed by a processor to implement the robustness detection method as described in any one of claims 1 to 9.

Images