Test method and device for low-code system and electronic equipment

Abstract

The invention provides a test method and device for a low-code system and electronic equipment. The test method comprises the steps of obtaining test factor items corresponding to the low-code system; combining the test factor items into a test case set through orthogonal analysis; according to a preset test demand, determining rule data for realizing the test demand, and filling the test case set into the rule data to generate a target test scene; and executing the target test scene through a preset test script, and determining a use case execution result. The test case can be automatically generated, the test human input is reduced, the reusability of the case is enhanced, and the test quality is improved.

Description

Technical Field

[0001] The present disclosure relates to the technical field of system testing, and in particular to a testing method, device and electronic equipment for a low-code system. Background Art

[0002] At present, in the low-code work order system, the work order is dynamically constructed, and the master file data of different enterprise business scenarios is relatively fixed, but the data generation process caused by process differentiation is uncontrollable. The testing process of the conventional work order configuration system usually adopts the method of purely manual disassembly of the customer business scenario, and the business node and data verification is performed through the continuous combination after the enumeration of the controls. This method is time-consuming and requires a large manpower cost. Some front-end companies use interface automation to perform data function verification of specific work order processes and nodes, but the reusability for different enterprise work order scenarios is poor. Therefore, the testing method of the existing low-code system still uses a building block framework, which leads to the generalization of various combination use cases, large volume, high cost, and the inability to quickly copy the configuration results of each customer work order, resulting in low value output. Summary of the invention

[0003] The embodiments of the present disclosure at least provide a testing method, device and electronic device for a low-code system, which can automatically generate test cases, reduce the manpower investment in testing, and at the same time enhance the reusability of use cases and improve the testing quality.

[0004] The present disclosure provides a method for testing a low-code system, including:

[0005] Get the test factor items corresponding to the low-code system;

[0006] Combining the test factor items into a test case set through orthogonal analysis;

[0007] According to the preset test requirements, determine the rule data to realize the test requirements, and fill the test case set into the rule data to generate a target test scenario;

[0008] The target test scenario is executed through a preset test script to determine the use case execution result.

[0009] In an optional implementation manner, obtaining the test factor items corresponding to the low-code system specifically includes:

[0010] By presetting a front-end user interaction interface, in response to a user's submission operation, obtaining the test factor items enumerated by the user for the low-code system;

[0011] Construct a factor item table corresponding to the test factor items.

[0012] In an optional implementation manner, combining the test factor items into a test case set by orthogonal analysis specifically includes:

[0013] Retrieve a preset orthogonal analysis module and receive the factor item table sent by the front-end user interface;

[0014] The test factor items carried in the factor item table are automatically combined into the test case set by using an orthogonal analysis algorithm.

[0015] In an optional implementation manner, after the orthogonal analysis algorithm is used to automatically combine the test factor items carried in the factor item table into the test case set, the method further includes:

[0016] Sending the test case set to the front-end user interaction interface so that the front-end user interaction interface displays the test case set;

[0017] In response to a confirmation operation on the test case set, a generation process of the target test scenario is triggered.

[0018] In an optional implementation, determining rule data for implementing the test requirements according to preset test requirements, and filling the test case set into the rule data to generate a target test scenario specifically includes:

[0019] Calling a preset case processing module, receiving the test case set returned by the front-end user interaction interface, and generating the target test scenario;

[0020] The target test scenario is sent to the front-end user interaction interface so that the front-end user interaction interface displays the target test scenario.

[0021] In an optional implementation, executing the target test scenario through a preset test script to determine the use case execution result specifically includes:

[0022] Retrieve a preset script case module of the built-in preset test script, and automatically execute the scenario test case in the target test scenario through the test script;

[0023] Determine the use case execution result, and send the use case execution result to the front-end user interaction interface.

[0024] In an optional implementation manner, after executing the target test scenario through a preset test script and determining the use case execution result, the method further includes:

[0025] Obtaining, through the preset front-end user interaction interface, a receiving path and a target receiving address for a user to receive the execution result of the use case;

[0026] The use case execution result is sent to the target receiving address through the receiving path.

[0027] The present disclosure also provides a low-code system testing device, the device comprising:

[0028] An acquisition unit is used to obtain the test factor items corresponding to the low-code system;

[0029] An orthogonal analysis unit, used for combining the test factor items into a test case set through orthogonal analysis;

[0030] A case processing unit, configured to determine rule data for implementing the test requirements according to preset test requirements, and fill the test case set into the rule data to generate a target test scenario;

[0031] The script testing unit is used to execute the target test scenario through a preset test script and determine the use case execution result.

[0032] An embodiment of the present disclosure also provides an electronic device, including: a processor, a memory and a bus, wherein the memory stores machine-readable instructions executable by the processor, and when the electronic device is running, the processor and the memory communicate through the bus, and when the machine-readable instructions are executed by the processor, the test method of the low-code system mentioned above, or the steps in any possible implementation of the test method of the low-code system mentioned above are executed.

[0033] An embodiment of the present disclosure also provides a computer-readable storage medium, on which a computer program is stored. When the computer program is executed by a processor, the test method of the low-code system described above, or the steps of any possible implementation of the test method of the low-code system described above, is executed.

[0034] The embodiments of the present disclosure also provide a computer program product, including a computer program / instructions, which, when executed by a processor, implement the above-mentioned low-code system testing method, or the steps in any possible implementation of the above-mentioned low-code system testing method.

[0035] The disclosed embodiments provide a method, device and electronic device for testing a low-code system, which obtains test factor items corresponding to the low-code system; combines the test factor items into a test case set through orthogonal analysis; determines rule data for implementing the test requirements according to preset test requirements, and fills the test case set with the rule data to generate a target test scenario; executes the target test scenario through a preset test script to determine the case execution result. Test cases can be automatically generated, reducing the manpower input for testing, while enhancing the reusability of the case and improving the test quality.

[0036] In order to make the above-mentioned objectives, features and advantages of the present disclosure more obvious and easy to understand, preferred embodiments are specifically cited below and described in detail with reference to the attached drawings. BRIEF DESCRIPTION OF THE DRAWINGS

[0037] In order to more clearly illustrate the technical solutions of the embodiments of the present disclosure, the following is a brief introduction to the drawings required for use in the embodiments. The drawings herein are incorporated into the specification and constitute a part of the specification. These drawings illustrate embodiments consistent with the present disclosure and are used together with the specification to illustrate the technical solutions of the present disclosure. It should be understood that the following drawings only illustrate certain embodiments of the present disclosure and should not be regarded as limiting the scope. For ordinary technicians in this field, other relevant drawings can also be obtained based on these drawings without creative work.

[0038] Figure 1 A flowchart of a low-code system testing method provided by an embodiment of the present disclosure is shown;

[0039] Figure 2 An interactive schematic diagram of a test system of a low-code system provided by an embodiment of the present disclosure is shown;

[0040] Figure 3 A schematic diagram of a testing device for a low-code system provided by an embodiment of the present disclosure is shown;

[0041] Figure 4 A schematic diagram of an electronic device provided by an embodiment of the present disclosure is shown. DETAILED DESCRIPTION

[0042] In order to make the purpose, technical scheme and advantages of the embodiments of the present disclosure clearer, the technical scheme in the embodiments of the present disclosure will be clearly and completely described below in conjunction with the drawings in the embodiments of the present disclosure. Obviously, the described embodiments are only part of the embodiments of the present disclosure, rather than all of the embodiments. The components of the embodiments of the present disclosure generally described and shown in the drawings here can be arranged and designed in various different configurations. Therefore, the following detailed description of the embodiments of the present disclosure provided in the drawings is not intended to limit the scope of the present disclosure for protection, but merely represents the selected embodiments of the present disclosure. Based on the embodiments of the present disclosure, all other embodiments obtained by those skilled in the art without making creative work belong to the scope of protection of the present disclosure.

[0043] It should be noted that similar reference numerals and letters denote similar items in the following drawings, and therefore, once an item is defined in one drawing, further definition and explanation thereof is not required in subsequent drawings.

[0044] The term "and / or" herein only describes an association relationship, indicating that three relationships may exist. For example, A and / or B may represent the following three situations: A exists alone, A and B exist at the same time, and B exists alone. In addition, the term "at least one" herein represents any combination of at least two of any one or more of a plurality of. For example, including at least one of A, B, and C may represent including any one or more elements selected from the set consisting of A, B, and C.

[0045] Research has found that, at present, in the low-code work order system, the work order is dynamically constructed, and the master file data of different enterprise business scenarios is relatively fixed, but the data generation process caused by the process differentiation is uncontrollable. The testing process of the conventional work order configuration system usually adopts the method of purely manual disassembly of the customer business scenario, and the business node and data verification is performed through the continuous combination after the enumeration of the controls. This method is time-consuming and requires a large manpower cost. Some front-end companies use interface automation to perform data function verification of specific work order processes and nodes, but the reusability for different enterprise work order scenarios is poor. Therefore, the testing method of the existing low-code system still uses a building block framework, which leads to the generalization of various combination use cases, large volume, high cost, and the inability to quickly copy the configuration results of each customer work order, resulting in low value output.

[0046] Based on the above research, the present disclosure provides a testing method, device and electronic device for a low-code system, which obtains the test factor items corresponding to the low-code system; combines the test factor items into a test case set through orthogonal analysis; determines the rule data for implementing the test requirements according to the preset test requirements, and fills the test case set with the rule data to generate a target test scenario; executes the target test scenario through a preset test script to determine the case execution result. Test cases can be automatically generated, reducing the manpower input for testing, while enhancing the reusability of the case and improving the test quality.

[0047] To facilitate understanding of the present embodiment, a test method for a low-code system disclosed in the embodiment of the present disclosure is first introduced in detail. The execution subject of the test method for a low-code system provided in the embodiment of the present disclosure is generally a computer device with certain computing capabilities, and the computer device includes, for example: a terminal device or a server or other processing device. The terminal device may be a user equipment (UE), a mobile device, a user terminal, a terminal, a cellular phone, a cordless phone, a personal digital assistant (PDA), a handheld device, a computing device, a vehicle-mounted device, a wearable device, etc. In some possible implementations, the test method for the low-code system may be implemented by a processor calling computer-readable instructions stored in a memory.

[0048] See also Figure 1 As shown, it is a flowchart of a low-code system testing method provided by an embodiment of the present disclosure, and the method includes steps S101 to S104, wherein:

[0049] S101. Obtain the test factor items corresponding to the low-code system.

[0050] In the specific implementation, the test factor items that affect the low-code system testing process are obtained.

[0051] Here, factor points can be sorted out based on the existing space, process and other factors of the low-code system. The processing process may include: control enumeration, control content enumeration, process node enumeration, permission scenario enumeration, etc.

[0052] For example, in the process of sorting out the factors, the control enumeration is: drop-down box; the control content enumeration is: male, female; the permission enumeration is: all user permissions, some user permissions; the process enumeration is: review, copy, etc. The corresponding test factor items are: drop-down box, male, female, all user permissions, some user permissions, review, copy, etc.

[0053] As a possible implementation, step S101 may be implemented through the following steps S1011 to S1012:

[0054] S1011. Through a preset front-end user interaction interface, in response to a user's submission operation, obtain the test factor items enumerated by the user for the low-code system.

[0055] S1012: Construct a factor item table corresponding to the test factor items.

[0056] In the specific implementation, a front-end user interaction interface is provided to realize human-computer interaction with users. Through the front-end user interaction interface, the test factor items input by the user after sorting out the existing space, process and other factor points of the low-code system are obtained, and the test factor items are constructed into a corresponding factor item table according to the corresponding factor item type.

[0057] S102. Combining the test factor items into a test case set through orthogonal analysis.

[0058] In a specific implementation, the test factor items are processed by an orthogonal analysis algorithm and automatically combined into a test case set. The test case set includes multiple test cases, each test case is composed of various types of test factor items, and the combination of test factor items is different in different test cases.

[0059] Here, the orthogonal analysis combination of the enumerated test factor items is performed using a scripting language or tool to automatically generate test case scenarios for the factor items. Since there are multiple controls in the interface in the low-code system, and each control corresponds to a test factor item, that is, there are multiple combination relationships between the controls, and there are also multiple combination relationships between the test factor items. In order to adapt to more combination relationships, it is not necessary to test all combinations. Therefore, an orthogonal analysis algorithm is used in the embodiment of the present application. After being processed by the orthogonal analysis algorithm, the minimum test case combination used to cover the multiple combination relationships between multiple use cases can be obtained, that is, a small number of better combinations are selected from all combinations for testing.

[0060] Among them, a test case refers to a description of a test task for a specific software product, reflecting the test plan, methods, techniques and strategies, including test objectives, test environment, input data, test steps, expected results, test scripts, etc., and finally forms a document. In other words, a test case is a set of test inputs, execution conditions and expected results compiled for a special goal, which is used to verify whether a specific software requirement is met.

[0061] Exemplarily, the test case set may include: Test case 1: the control factor item is male, the permission factor item is all user permissions, and the process node factor item is review; Test case 2: the control factor item is male, the permission factor item is partial user permissions, and the process node factor item is CC; Test case 3: the control factor item is female, the permission factor item is all user permissions, and the process node factor item is review; Test case 4: the control factor item is female, the permission factor item is partial user permissions, and the process node factor item is CC.

[0062] As a possible implementation, step S102 may be implemented through the following steps S1021-S1022:

[0063] S1021, calling a preset orthogonal analysis module, and receiving the factor item table sent by the front-end user interface;

[0064] S1022. Using an orthogonal analysis algorithm, the test factor items carried in the factor item table are automatically combined into the test case set.

[0065] In the specific implementation, the software development staff provides in advance an orthogonal analysis module connected to the front-end user interaction interface, and the orthogonal analysis module can realize the orthogonal analysis operation function. The front-end user interaction interface sends the factor item table submitted by the user to the orthogonal analysis module, and the orthogonal analysis module uses the orthogonal analysis algorithm to orthogonally arrange the test factor items carried in the factor item table, and then uses different combination methods to combine them into multiple test cases, and all the test cases constitute a test case set.

[0066] As a possible implementation, after the orthogonal analysis algorithm is used to automatically combine the test factor items carried in the factor item table into the test case set, the method also includes: sending the test case set to the front-end user interaction interface, and displaying the test case set to the user through the front-end user interaction interface; in response to the user's confirmation operation on the test case set, triggering the generation process of the target test scenario.

[0067] S103 . According to preset test requirements, determine rule data for implementing the test requirements, and fill the test case set into the rule data to generate a target test scenario.

[0068] In the specific implementation, the preset use case data processing module is called to receive the test case set returned by the front-end user interaction interface. According to the preset test requirements, the rule data for implementing the test actions indicated in the test requirements are extracted in the code layer of the low-code system, and each test case in the test case set is filled into the corresponding position in the rule data to generate the target test scenario; the target test scenario is sent to the front-end user interaction interface and displayed to the user through the front-end user interaction interface.

[0069] Among them, the rule data is computer executable computer rule language data extracted from the code layer of the low-code system in order to implement the test actions indicated by the test requirements. The test factor item combinations contained in the test case are filled in the corresponding positions of the computer rule language data to generate a test scenario for verifying whether the test requirements can be met under the influence of each group of test factor item combinations.

[0070] For example, when the test requirement is "requiring a correct super-administrator account and password to log in", then the test action indicated by the test requirement is the action of "logging in with the correct super-administrator account and password". Therefore, it is necessary to determine the computer executable rule data for executing "logging in with the correct super-administrator account and password", that is, extract the "request URL, request method, message, header file, etc." of the code layer, and fill in the test factor item combination in the test case set as parameters, so as to verify whether the code satisfies the correct account and password to log in, and whether the incorrect login operation is intercepted.

[0071] Here, by calling the use case data processing module that is pre-configured by the software developer and can realize the use case data processing function, the pre-written test case processing script carried in the use case data processing module is used to convert the requirement rule language into a computer rule language, and each group of test cases in the test case set is filled in the computer rule language according to the requirements of the rules and the corresponding positions marked in the computer rule language to assemble into a formal test scenario.

[0072] It should be noted that the target test scenario is a set of test cases, which includes the testing process of multiple test cases. It describes the different scenarios that users may face when using the program. It can help test whether there are potential errors and vulnerabilities when different scenarios occur during the operation of the system, so as to ensure that the end-to-end functions of the program can run normally as expected.

[0073] Exemplarily, corresponding to the test case set 1-4 listed in step S102, the corresponding target test scenario can be: after the user selects gender, authority and process type in the corresponding control, whether the program can execute the review or copy function corresponding to the selected process type, or whether the execution result after the program executes the review or copy function corresponding to the selected process type meets the authority factor item selected by the user, etc.

[0074] Among them, the target test scenario still needs to be displayed to the user through the front-end user interaction interface for user confirmation.

[0075] S104: Execute the target test scenario through a preset test script to determine the use case execution result.

[0076] In the specific implementation, the preset test script is driven by the structured interface automation framework component method to realize the automatic execution of the test case and obtain the test result.

[0077] As a possible implementation, step S104 may be implemented through the following steps S1041-S1042:

[0078] S1041, calling a preset script case module of the built-in preset test script, and automatically executing the scenario test case in the target test scenario through the test script.

[0079] S1042: Determine the use case execution result, and send the use case execution result to the front-end user interaction interface.

[0080] In the specific implementation, the script use case module with built-in preset test scripts processes the scenario test cases in the target test scenario sent by the use case data processing module, and sends the use case execution results to the front-end user interaction interface, which displays the use case execution results to the user.

[0081] Here, a test script is a piece of automation script or code pre-written by a test engineer to execute test cases to achieve the target scenario and verify the expected results, so as to achieve the effect of automated testing using a specific testing framework, programming language, and tools.

[0082] Among them, the test script can simulate the user's operation, automatically execute a series of test steps to achieve the target test scenario, and verify it according to the use case execution results.

[0083] It should be noted that after determining the use case execution result, the receiving path and target receiving address for the user to receive the use case execution result can also be obtained through the preset front-end user interaction interface; the use case execution result is sent to the target receiving address through the receiving path.

[0084] Here, the receiving path can be a communication method such as email, text message, etc., and the corresponding target receiving address can be the user's email address, mobile phone number, etc.

[0085] As a possible implementation, the low-code system testing method provided in the embodiment of the present disclosure can be applied to a low-code system testing system, see Figure 2 , which is an interactive schematic diagram of a low-code system test system provided by an embodiment of the present disclosure. The low-code system test system includes a front-end user interaction interface 200, an orthogonal analysis module 210, a use case processing module 220, and a script use case module 230.

[0086] In a specific implementation, the front-end user interaction interface 200 is used to obtain the test factor items corresponding to the low-code system; the orthogonal analysis module 210 is used to combine the test factor items into a test case set through orthogonal analysis; the case processing module 220 is used to determine the rule data for implementing the test requirements according to the preset test requirements, and fill the test case set with the rule data; the script case module 230 is used to execute the target test scenario through a preset test script and determine the case execution result.

[0087] Specifically, the implementation steps of the interactive mode of the test system of the low-code system can be referred to the following steps S201 to S213:

[0088] S201 : A user submits a test factor item to the front-end user interaction interface 200 .

[0089] In the specific implementation, the user interacts with the front-end user interaction interface 200, and submits the factor points based on the existing space, process and other factor points of the low-code system on the front-end user interaction interface 200 in an interactive manner such as input to sort out the factor points, and enumerates the test factor items such as controls, control contents, process nodes, and permission scenarios.

[0090] Here, the user can submit the test factor items in the front-end user interaction interface 200 in the form of a table, and a factor item table is generated after the submission is completed.

[0091] S202 , the front-end user interaction interface 200 sends the factor item table submitted by the user to the orthogonal analysis module 210 .

[0092] S203 , the orthogonal analysis module 210 performs an orthogonal analysis on the factor item table sent by the front-end user interaction interface 200 to construct a test case set.

[0093] In a specific implementation, the orthogonal analysis module 210 arranges and combines the test factor items submitted in the factor item table using an orthogonal analysis algorithm, covers the pairwise combinations of multiple test factor item values ​​through the minimum test factor item combinations, and uses each test factor item combination as a test case to generate a test case set.

[0094] The orthogonal analysis module 210 may use an orthogonal analysis script language or an orthogonal analysis algorithm tool.

[0095] S204 , the orthogonal analysis module 210 returns the test case set to the front-end user interaction interface 200 .

[0096] S205. The front-end user interaction interface 200 displays the test case set to the user.

[0097] S206 : The user confirms the test case set in the front-end user interaction interface 200 .

[0098] In a specific implementation, after generating the test case set, the orthogonal analysis module 210 returns the generated test case set to the front-end user interaction interface 200, and the front-end user interaction interface 200 displays the test case set to the user. The user views the test case set in the front-end user interaction interface 200, and after confirming that the test case set is correct, clicks the test case set confirmation control provided in the front-end user interaction interface 200 to perform the confirmation operation.

[0099] S207 . After the user confirms that the test case set is correct, the front-end user interaction interface 200 sends the test case set to the case processing module 220 .

[0100] S208. The use case processing module 220 processes the use case data to generate a target test scenario.

[0101] In a specific implementation, the use case processing module 220 can generate scripts for pre-written rules, convert the requirement rule language of the test requirements into a computer rule language executable by a computer, extract the test data that implements the test requirements to form a rule script, concentrate the test cases, and fill the test factor item combination of each test case into the rule script to generate a target test scenario.

[0102] S209 , the use case processing module 220 returns the target test scenario to the front-end user interaction interface 200 .

[0103] S210 , the use case processing module 220 sends the target test scenario to the script use case module 230 .

[0104] In a specific implementation, after processing the test case set to generate a target test scenario, the use case processing module 220 sends the target test scenario to the front-end user interaction interface 200 and the script use case module 230 respectively, and the user can view the target test scenario through the front-end user interaction interface 200.

[0105] S211. The script case module 230 executes the target test scenario and determines the execution result of the test case.

[0106] In a specific implementation, the script case module 230 can adopt an interface automated testing framework model, execute target test scenarios through built-in test scripts, realize automatic execution of test cases, and obtain test results.

[0107] S212 , the script case module 230 sends the test case execution result to the front-end user interaction interface 200 .

[0108] S213, the script case module 230 feeds back the test case execution result to the user.

[0109] In a specific implementation, after generating the test case execution result, the script case module 230 sends the test case execution result to the front-end user interaction interface 200 and the user, and the user can view the test result of this test through the front-end user interaction interface 200.

[0110] Here, the script case module 230 can call a preset test result report template, fill in the test case execution result at the corresponding position of the test result report template, generate a test result report, and send the test result report to the user in the form of an email.

[0111] The present disclosure provides a method for testing a low-code system, which obtains test factor items corresponding to the low-code system; combines the test factor items into a test case set through orthogonal analysis; determines rule data for implementing the test requirements according to preset test requirements, and fills the test case set with the rule data to generate a target test scenario; executes the target test scenario through a preset test script to determine the case execution result. Test cases can be automatically generated, reducing the manpower input for testing, while enhancing the reusability of the case and improving the test quality.

[0112] Those skilled in the art will appreciate that, in the above method of specific implementation, the order in which the steps are written does not imply a strict execution order and does not constitute any limitation on the implementation process. The specific execution order of the steps should be determined by their functions and possible internal logic.

[0113] Based on the same inventive concept, the presently disclosed embodiment also provides a testing device for a low-code system corresponding to the testing method for a low-code system. Since the principle of solving the problem by the device in the presently disclosed embodiment is similar to the testing method for the low-code system in the presently disclosed embodiment, the implementation of the device can refer to the implementation of the method, and the repeated parts will not be repeated.

[0114] See also Figure 3 , Figure 3 A schematic diagram of a low-code system testing device provided in an embodiment of the present disclosure. Figure 3 As shown in , the testing device 300 of the low-code system provided by the embodiment of the present disclosure includes:

[0115] The acquisition unit 310 is used to obtain the test factor items corresponding to the low-code system.

[0116] The orthogonal analysis unit 320 is used to combine the test factor items into a test case set through orthogonal analysis.

[0117] The case processing unit 330 is used to determine the rule data for realizing the test requirements according to the preset test requirements, and fill the test case set into the rule data to generate a target test scenario.

[0118] The script testing unit 340 is used to execute the target test scenario through a preset test script to determine the use case execution result.

[0119] For descriptions of the processing flow of each module in the device and the interaction flow between each module, reference may be made to the relevant descriptions in the above method embodiment, which will not be described in detail here.

[0120] The present disclosure provides a test device for a low-code system, which obtains test factor items corresponding to the low-code system; combines the test factor items into a test case set through orthogonal analysis; determines rule data for implementing the test requirements according to preset test requirements, and fills the test case set with the rule data to generate a target test scenario; executes the target test scenario through a preset test script to determine the case execution result. Test cases can be automatically generated, reducing the manpower input for testing, while enhancing the reusability of the case and improving the test quality.

[0121] Corresponds to Figure 1 The present disclosure also provides an electronic device 400, such as Figure 4 FIG. 4 is a schematic diagram of the structure of an electronic device 400 provided in an embodiment of the present disclosure, including:

[0122] Processor 41, memory 42, and bus 43; memory 42 is used to store execution instructions, including memory 421 and external memory 422; memory 421 here is also called internal memory, which is used to temporarily store operation data in processor 41 and data exchanged with external memory 422 such as hard disk. Processor 41 exchanges data with external memory 422 through memory 421. When the electronic device 400 is running, the processor 41 communicates with the memory 42 through bus 43, so that the processor 41 executes Figure 1 Steps in the testing methodology for low-code systems.

[0123] The present disclosure also provides a computer-readable storage medium on which a computer program is stored. When the computer program is executed by a processor, the steps of the method for testing a low-code system described in the above method embodiment are executed. The storage medium may be a volatile or non-volatile computer-readable storage medium.

[0124] The embodiments of the present disclosure also provide a computer program product, which includes computer instructions. When the computer instructions are executed by a processor, the steps of the low-code system testing method described in the above method embodiment can be executed. For details, please refer to the above method embodiment, which will not be repeated here.

[0125] The computer program product may be implemented in hardware, software or a combination thereof. In one optional embodiment, the computer program product is implemented as a computer storage medium. In another optional embodiment, the computer program product is implemented as a software product, such as a software development kit (SDK).

[0126] Those skilled in the art can clearly understand that, for the convenience and simplicity of description, the specific working process of the system and device described above can refer to the corresponding process in the aforementioned method embodiment, and will not be repeated here. In the several embodiments provided in the present disclosure, it should be understood that the disclosed system, device and method can be implemented in other ways. The device embodiments described above are merely schematic. For example, the division of the units is only a logical function division. There may be other division methods in actual implementation. For example, multiple units or components can be combined or integrated into another system, or some features can be ignored or not executed. Another point is that the mutual coupling or direct coupling or communication connection shown or discussed can be through some communication interfaces, and the indirect coupling or communication connection of the device or unit can be electrical, mechanical or other forms.

[0127] The units described as separate components may or may not be physically separated, and the components shown as units may or may not be physical units, that is, they may be located in one place or distributed on multiple network units. Some or all of the units may be selected according to actual needs to achieve the purpose of the solution of this embodiment.

[0128] In addition, each functional unit in each embodiment of the present disclosure may be integrated into one processing unit, or each unit may exist physically separately, or two or more units may be integrated into one unit.

[0129] If the functions are implemented in the form of software functional units and sold or used as independent products, they can be stored in a non-volatile computer-readable storage medium that is executable by a processor. Based on this understanding, the technical solution of the present disclosure, or the part that contributes to the prior art or the part of the technical solution, can be embodied in the form of a software product, which is stored in a storage medium and includes several instructions for a computer device (which can be a personal computer, a server, or a network device, etc.) to perform all or part of the steps of the method described in each embodiment of the present disclosure. The aforementioned storage medium includes: various media that can store program codes, such as a USB flash drive, a mobile hard disk, a read-only memory (ROM), a random access memory (RAM), a magnetic disk or an optical disk.

[0130] Finally, it should be noted that the above-described embodiments are only specific implementation methods of the present disclosure, which are used to illustrate the technical solutions of the present disclosure, rather than to limit them. The protection scope of the present disclosure is not limited thereto. Although the present disclosure is described in detail with reference to the above-described embodiments, ordinary technicians in the field should understand that any technician familiar with the technical field can still modify the technical solutions recorded in the above-described embodiments within the technical scope disclosed in the present disclosure, or can easily think of changes, or make equivalent replacements for some of the technical features therein; and these modifications, changes or replacements do not make the essence of the corresponding technical solutions deviate from the spirit and scope of the technical solutions of the embodiments of the present disclosure, and should be included in the protection scope of the present disclosure. Therefore, the protection scope of the present disclosure should be based on the protection scope of the claims.

Claims

1. A testing method for a low-code system, characterized in that: include: Get the test factor items corresponding to the low-code system; Combining the test factor items into a test case set through orthogonal analysis; According to the preset test requirements, determine the rule data to realize the test requirements, and fill the test case set into the rule data to generate a target test scenario; The target test scenario is executed through a preset test script to determine the use case execution result.

2. The method according to claim 1, characterized in that The obtaining of the test factor items corresponding to the low-code system specifically includes: By presetting a front-end user interaction interface, in response to a user's submission operation, obtaining the test factor items enumerated by the user for the low-code system; Construct a factor item table corresponding to the test factor items.

3. The method according to claim 2, characterized in that The combining of the test factor items into a test case set by orthogonal analysis specifically includes: Retrieve a preset orthogonal analysis module and receive the factor item table sent by the front-end user interface; The test factor items carried in the factor item table are automatically combined into the test case set by using an orthogonal analysis algorithm.

4. The method according to claim 3, characterized in that After the orthogonal analysis algorithm is used to automatically combine the test factor items carried in the factor item table into the test case set, the method further includes: Sending the test case set to the front-end user interaction interface so that the front-end user interaction interface displays the test case set; In response to a confirmation operation on the test case set, a generation process of the target test scenario is triggered.

5. The method according to claim 2, characterized in that: The step of determining rule data for realizing the test requirements according to the preset test requirements, and filling the test case set into the rule data to generate a target test scenario specifically includes: Calling a preset case processing module, receiving the test case set returned by the front-end user interaction interface, and generating the target test scenario; The target test scenario is sent to the front-end user interaction interface so that the front-end user interaction interface displays the target test scenario.

6. The method according to claim 2, characterized in that Execute the target test scenario through the preset test script to determine the use case execution result, which specifically includes: Retrieve a preset script case module of the built-in preset test script, and automatically execute the scenario test case in the target test scenario through the test script; Determine the use case execution result, and send the use case execution result to the front-end user interaction interface.

7. The method according to claim 2, characterized in that After executing the target test scenario through the preset test script and determining the use case execution result, the method further includes: Obtaining, through the preset front-end user interaction interface, a receiving path and a target receiving address for a user to receive the execution result of the use case; The use case execution result is sent to the target receiving address through the receiving path.

8. A testing device for a low-code system, characterized in that: include: An acquisition unit is used to obtain the test factor items corresponding to the low-code system; An orthogonal analysis unit, used for combining the test factor items into a test case set through orthogonal analysis; A case processing unit, configured to determine rule data for implementing the test requirements according to preset test requirements, and fill the test case set into the rule data to generate a target test scenario; The script testing unit is used to execute the target test scenario through a preset test script and determine the use case execution result.

9. An electronic device, characterized in that: include: A processor, a memory and a bus, wherein the memory stores machine-readable instructions executable by the processor. When the electronic device is running, the processor and the memory communicate through the bus. When the machine-readable instructions are executed by the processor, the steps of the low-code system testing method as described in any one of claims 1 to 7 are performed.

10. A computer-readable storage medium, characterized in that: A computer program is stored on the computer-readable storage medium, and when the computer program is executed by the processor, the steps of the testing method of the low-code system as described in any one of claims 1 to 7 are executed.

Images