CN112445692B

CN112445692B - Case testing method and terminal

Info

Publication number: CN112445692B
Application number: CN201910795895.5A
Authority: CN
Inventors: 丁永亮
Original assignee: Tencent Technology Shenzhen Co Ltd
Current assignee: Tencent Technology Shenzhen Co Ltd
Priority date: 2019-08-27
Filing date: 2019-08-27
Publication date: 2024-01-26
Anticipated expiration: 2039-08-27
Also published as: CN112445692A

Abstract

The disclosure provides a use case testing method and a terminal, wherein the method comprises the following steps: acquiring a service circulation path of a test case to be tested; constructing a test scene inside a service circulation path; and testing the test case to be tested according to the test scene. The embodiment of the disclosure can improve the coverage rate of the test scenario of the use case test.

Description

Case testing method and terminal

Technical Field

The disclosure relates to the field of computer system testing, in particular to a use case testing method and a terminal.

Background

In computer system testing, testing of a system under test is often accomplished by testing a use case of the system under test. Specifically, before testing a use case, a specific test scene of the use case needs to be constructed, so that the use case under the specific test scene is tested.

In the prior art, a test scene is firstly constructed outside a service circulation path of a use case, and then the use case is tested according to the test scene of the external construction. The test scene constructed by the method often cannot fully cover the test scene of the use case, so that the coverage rate of the test scene of the use case test is low.

Disclosure of Invention

An object of the present disclosure is to provide a method and a terminal for testing a case, so as to improve coverage of a test scenario of the case test.

According to an aspect of the disclosed embodiments, a use case testing method is disclosed, the method comprising:

acquiring a service circulation path of a test case to be tested;

constructing a test scene inside a service circulation path;

and testing the test case to be tested according to the test scene.

According to an aspect of the disclosed embodiments, a use case testing terminal is disclosed, the terminal comprising:

the acquisition module is used for acquiring a service circulation path of the test case to be tested;

the construction module is used for constructing a test scene in the service circulation path;

and the test module is used for testing the test case to be tested according to the test scene.

In the prior art, a test scene is constructed outside a service circulation path of a test case to be tested, namely, branches possibly appearing in the service circulation path are considered from a service flow node level, so that the test scene is constructed. Therefore, the grain fineness of the structure of the test scene in the prior art is stopped at the level of the business process node, and the coverage rate of the test scene is low. When the embodiment of the disclosure is used for carrying out case testing, a testing scene is constructed in the service flow path of the to-be-tested case, namely, branches possibly appearing in the service flow path are considered from the function node level of the computer system, and then the testing scene is constructed. Therefore, the embodiment of the disclosure can construct the test scene with smaller granularity, and improves the coverage rate of the test scene of the use case test.

Other features and advantages of the present disclosure will be apparent from the following detailed description, or may be learned in part by the practice of the disclosure.

It is to be understood that both the foregoing general description and the following detailed description are exemplary and explanatory only and are not restrictive of the disclosure.

Drawings

The above and other objects, features and advantages of the present disclosure will become more apparent by describing in detail exemplary embodiments thereof with reference to the attached drawings.

FIG. 1 illustrates an architecture diagram of a use case testing method according to one embodiment of the present disclosure.

Fig. 2 illustrates a schematic diagram of an internal structure of a service circulation path according to an embodiment of the present disclosure.

Fig. 3 illustrates logical structure composition according to one embodiment of the present disclosure.

Fig. 4 illustrates logical structure composition according to one embodiment of the present disclosure.

FIG. 5 illustrates a flow chart of a use case testing method according to one embodiment of the present disclosure.

Fig. 6 shows a block diagram of a use case testing terminal according to one embodiment of the present disclosure.

Fig. 7 shows a hardware configuration diagram of a use case testing terminal according to an embodiment of the present disclosure.

Detailed Description

Example embodiments will now be described more fully with reference to the accompanying drawings. However, the exemplary embodiments may be embodied in many forms and should not be construed as limited to the examples set forth herein; rather, these example embodiments are provided so that this disclosure will be thorough and complete, and will fully convey the concept of the example embodiments to those skilled in the art. The drawings are merely schematic illustrations of the present disclosure and are not necessarily drawn to scale. The same reference numerals in the drawings denote the same or similar parts, and thus a repetitive description thereof will be omitted.

Furthermore, the described features, structures, or characteristics may be combined in any suitable manner in one or more example embodiments. In the following description, numerous specific details are provided to give a thorough understanding of example embodiments of the disclosure. One skilled in the relevant art will recognize, however, that the aspects of the disclosure may be practiced without one or more of the specific details, or with other methods, components, steps, etc. In other instances, well-known structures, methods, implementations, or operations are not shown or described in detail to avoid obscuring aspects of the disclosure.

Some of the block diagrams shown in the figures are functional entities and do not necessarily correspond to physically or logically separate entities. These functional entities may be implemented in software or in one or more hardware modules or integrated circuits or in different networks and/or processor devices and/or microcontroller devices.

The architecture of an embodiment of the present disclosure is described below first with reference to fig. 1.

Fig. 1 shows the entities involved in the architecture of an embodiment of the present disclosure: test executor 10 and system under test 20. The test executor 10 controls the structure of the test scene of the test case to be tested, and the tested system 20 operates the test scene constructed by the test executor 10, so as to obtain an operation result and realize the test of the test case to be tested.

Specifically, the test executor 10 acquires a service circulation path of a test case to be tested in the tested system 20, and constructs a test scene in the service circulation path; further, the tested system 20 runs the test scene constructed by the test executor 10 in the service circulation path to obtain a running result; further, the test executor 10 obtains the test result of the test case to be tested through analyzing the operation result, and realizes the test of the test case to be tested.

Fig. 2 shows the internal structure of the traffic flow path in one embodiment. In this embodiment, for a service circulation path of the test case to be tested, execution of the service circulation path is performed according to the order in which the function node a calls the function node B, the function node B calls the function node C, and the function node C calls the function node D. The test executor monitors and intercepts information activities among function nodes by arranging hooks. And each time the test executor executes interception, a test scene can be correspondingly constructed at a hook interception point according to a preset test scene rule.

It should be noted that the embodiments are merely exemplary illustrations and should not be construed as limiting the function and scope of the present disclosure.

In order to more fully illustrate the implementation of the embodiments of the present disclosure, before describing the implementation of the embodiments of the present disclosure in detail, the following briefly describes the logical structure components of an embodiment of the present disclosure with reference to fig. 3 and fig. 4.

Fig. 3 illustrates the entities and major logical structural components involved in an embodiment of the present disclosure. The entities involved in this embodiment are: the system comprises a test executor and a tested system; the related main logic structure comprises the following components: the system comprises a service circulation path set, an accurate path set, a master control hook, an agent hook and a test scene rule.

The service circulation path refers to a path executed by the tested system when the tested system performs service circulation, and in particular, in the computer system, the service circulation path is embodied as a function call link executed by the tested system, as shown in fig. 2.

For example: when the tested system carries out refund related service circulation, the refund to WeChat balance is a service circulation path of the tested system; specifically, in the computer system, the service flow path of refund to WeChat balance can be embodied as a function call link of function node A calling function node B, function node B calling function node C, and function node C calling function node D.

The service circulation path set refers to a set of all paths possibly executed when the tested system performs service circulation.

For example: all possible paths executed by the tested system when the service flows are- "refund to WeChat balance", "refund to bank card", "transfer to WeChat balance" and "transfer to bank card". The service circulation path set of the tested system is the [ refund to WeChat balance "," refund to bank card "," transfer to WeChat balance "," transfer to bank card "].

The accurate path set is a specific use case of the pointer to the tested system, and in the process of testing the use case, the service circulation path of the use case which has not been tested is cut off to the current time point of testing.

For example: in the tested system, all the service circulation paths of the use case of refund are-refund to WeChat balance and refund to bank card. And (3) stopping the current time point of the test, wherein the service circulation path of the refund to WeChat balance is already tested, and the service circulation path of the use case which is not tested is the refund to Bank card, so that the accurate path set of the use case is the 'refund to Bank card' at the current time point.

The Master Hook (i.e., hook Master) is the same Hook (i.e., hook) as the proxy Hook (i.e., hook Agent). Hooks refer to a program that can monitor and intercept information activities. After the hook intercepts the information activity, the hook can replace the function node which is originally responsible for processing the information activity to carry out subsequent control on the information activity.

In the embodiment of the disclosure, the proxy hook is positioned in the tested system and is responsible for monitoring and intercepting the information activity of the service circulation path in the tested system and directly controlling the test scene construction in the service circulation path; the main control hook belonging to the same hook is positioned in the test executor and is responsible for communicating with the proxy hook, so that the information activity monitoring and interception condition of the proxy hook on the internal service circulation path of the tested system can be obtained in real time; the test executor sends an instruction related to constructing the test scene to the main control hook, so that the proxy hook is controlled to construct the test scene in the traffic flow path.

The test scene rule refers to a rule of how to construct a test scene inside the traffic flow path, and can be preset by a tester.

Specifically, after the service circulation path set and the accurate path set are read, the test executor controls the proxy hook through the main control hook according to the rule of the test scene and the information activity condition of the service circulation path in the tested system, and accordingly constructs the test scene in the service circulation path of the tested system.

Fig. 4 further illustrates the logical structure components, and the generation process of the logical structure components, according to an embodiment of the present disclosure. The logical structure composition of this embodiment includes: test execution logic, a service circulation path set, an accurate path set, a hook library, a master hook, a proxy hook and a test scene rule.

The test execution logic refers to a set of execution logic followed by the test executor in the whole process when the test executor tests the use case. The test execution logic is pre-written to the test executor by a tester, such that the test executor is able to execute embodiments of the present disclosure in accordance with the test execution logic.

The test executor carries out code preprocessing on a code source file in the tested system to obtain a function call chain of the tested system, and further obtains a service circulation path set.

The test executor carries out code preprocessing on the agent source file in the tested system, and can acquire a system application programming interface prototype and a service application programming interface prototype of the tested system besides acquiring a function call chain of the tested system, so as to generate a hook library aiming at the tested system. The hooks in the hook library can monitor and intercept information activities among function nodes in a service circulation path (specifically, the service circulation path embodied as a function call chain in a computer system), so as to construct a test scene inside the service circulation path. Specifically, the proxy hook monitors and intercepts information activities among function nodes in the service flow path, and the main control hook controls the proxy hook to construct a test scene in the service flow path.

The test executor correlates and maps each use case in the use case set of the tested system with the corresponding service circulation path, so as to obtain the mapping between each use case and the corresponding service circulation path. In the process of test execution, the test executor compares the service circulation paths which are tested and covered by the use case currently being tested with the corresponding service circulation paths mapped by the use case, so that an accurate path set of the use case at the current time point is obtained.

In this embodiment, the test executor reads the test scenario rule, the service flow path set and the accurate path set according to the test execution logic, and constructs a test scenario in the service flow path through the master hook and the proxy hook for the test case in the hook library, specifically, constructs the test scenario in the service flow path which is embodied as a function call chain in the computer system.

It should be noted that this embodiment is merely an exemplary brief description of an embodiment of the disclosure, and is intended to represent the general components and general flows of an embodiment of the disclosure during actual implementation, and should not be construed as limiting the function or scope of the disclosure.

A detailed description of the implementation of the embodiments of the present disclosure is provided below with reference to fig. 5.

The execution body of the embodiment of the disclosure is a test executor shown in fig. 1, and as shown in fig. 5, a use case test method includes:

step 310, acquiring a service circulation path of a test case to be tested;

step 320, constructing a test scene in the traffic flow path;

and 330, testing the test case to be tested according to the test scene.

When the embodiment of the disclosure tests the test case to be tested, a test scene is constructed in each service flow path aiming at each service flow path of the test case to be tested, and then the test case to be tested is tested according to the constructed test scene, so that the coverage rate of the test scene is improved.

In one embodiment, the test executor tests each use case in the system under test. The test executor tests each use case in the tested system as a test case to be tested according to the flow shown in fig. 5.

Therefore, before the test is executed on the test case to be tested, specifically, before the service circulation path of the test case to be tested is obtained, the service circulation path set of the tested system needs to be generated. The specific implementation process of the generation of the service circulation path set is described in detail below with reference to fig. 4.

In an embodiment, before the obtaining the service circulation path of the test case to be tested, the method includes:

acquiring a business method prototype of a tested system in which a test case to be tested is located;

acquiring a function call chain of a tested system in which a test case to be tested is located;

and acquiring each service circulation path in the tested system based on the service method prototype and the function call chain.

Business method prototypes refer to empty objects that can be instantiated as a specific business method, from which a business method prototype can derive a plurality of specific business methods.

A function call chain refers to a link describing a call relationship between function nodes.

By combining the service method prototype with the function call chain, a function node link describing the service circulation process, namely, a service circulation path can be obtained. Scoring for example: the service flow path is regarded as a building capable of realizing specific functions, the service method prototype is regarded as an instruction manual describing what specific functions the building is to be built with, the function call chain is regarded as a blueprint describing how connections are made between various types of foundation building materials under various conditions, and the function nodes are regarded as foundation building materials. And (3) connecting various basic building materials according to the combination of the instruction manual and the blueprint to obtain the building corresponding to the specific function.

In the embodiment, a test executor acquires a service method prototype of a tested system where a test case to be tested is located and a function call chain, and combines function nodes according to the function call chain according to the service method prototype, so as to obtain each service circulation path in the tested system, namely, a service circulation path set of the tested system is obtained.

The embodiment has the advantage that all business flow paths in the tested system can be acquired on the basis of the extraction of all business method prototypes and function call chains of the tested system.

In an embodiment, the obtaining a business method prototype of the tested system where the test case to be tested is located includes:

code preprocessing is carried out on a code source file of a tested system to obtain a grammar tree of the tested system;

traversing the grammar tree of the tested system to obtain the service method prototype of the tested system.

Syntax Tree (Syntax Tree), or abstract Syntax Tree AST (Abstract Syntax Tree), refers to the source code of the Tree representation of the abstract Syntax structure.

In this embodiment, the test executor performs code preprocessing on a code source file of the tested system, specifically, compiles a front-end processing on the code source file of the tested system, to obtain a syntax tree of the tested system. Traversing the grammar tree of the tested system to obtain each business method prototype in the tested system.

The embodiment has the advantage that all business method prototypes in the tested system can be completely obtained by traversing the grammar tree of the tested system.

In an embodiment, the traversing the syntax tree of the tested system to obtain the business method prototype of the tested system includes:

traversing the grammar tree according to the depth-first search algorithm in a recursion mode to obtain a business method prototype of the tested system.

The depth first search algorithm DFS (Depth First Search) is an algorithm for traversing a tree or graph, traversing nodes of the tree along the depth of the tree, searching branches of the tree as deep as possible, belonging to a blind search.

In an embodiment, the obtaining the function call chain of the tested system where the test case to be tested is located includes:

traversing the grammar tree of the tested system and obtaining the function call chain of the tested system.

The advantage of this embodiment is that by traversing the syntax tree of the system under test, all function call chains in the system under test can be completely large.

In one embodiment, the traversing the syntax tree of the tested system to obtain the function call chain of the tested system includes:

traversing the grammar tree according to a depth-first search algorithm in a recursion mode to obtain a function call chain of the tested system.

In one embodiment, the test executor implements test scene construction inside the traffic flow path through hooks. The service circulation path can involve various function nodes, and for different kinds of function nodes, different hooks are needed to monitor and intercept the function nodes.

Therefore, before the test is executed on the test case to be tested, specifically, before the service circulation path of the test case to be tested is obtained, a hook library for monitoring and intercepting all function nodes in the service circulation path needs to be generated. The specific implementation of the generation of the hook library is described in detail below in conjunction with fig. 4.

In one embodiment, before constructing the test scenario inside the service circulation path, the method includes:

acquiring an application programming interface prototype in a tested system where a test case to be tested is located;

For each application programming interface prototype, hooks are constructed that are defined identically to the application programming interface prototype.

An application programming interface prototype refers to a null object that can be instantiated as a specific application programming interface, from which the application programming interface prototype can be derived.

The application programming interfaces are interfaces for uniformly controlling the function nodes in the computer system, and each application programming interface can control the information activity of a corresponding part of the function nodes.

In this embodiment, the test executor obtains each application programming interface prototype from the tested system where the test case to be tested is located, and constructs, for each application programming interface prototype, a hook defined identically to the application programming interface prototype, thereby obtaining a hooked library.

The advantage of this embodiment is that by generating hooks having the same definition as each application programming interface prototype, the hooks are enabled to replace the application programming interfaces derived by each application programming interface prototype, and thus each function node can be controlled.

In an embodiment, the obtaining an application programming interface prototype in a tested system where the test case to be tested is located includes:

extracting a system application programming interface prototype of the tested system based on an official application programming interface document of the tested system;

And extracting a business application programming interface prototype of the tested system based on the official application programming interface document of the tested system.

The system application programming interface refers to an application programming interface for controlling a system basic operation function related function, and correspondingly, the system application programming interface prototype refers to a prototype of the application programming interface for controlling the system basic operation function related function.

The service application programming interface refers to an application programming interface for controlling a function related to a service flow function of the system, and the service application programming interface prototype refers to a prototype of the application programming interface for controlling the function related to the service flow function of the system.

In this embodiment, the test executor obtains the official application programming interface document of the tested system, and on this basis, extracts the system application programming interface prototype and the service application programming interface prototype of the tested system, and further constructs the hooks with the same definition for each application programming interface prototype.

In an embodiment, when the test executor tests the to-be-tested case, the test executor tests the service circulation path selected from the accurate path set of the case. From the above description, it can be seen that the precise path set refers to a set of service circulation paths that the test case to be tested has not been covered by the test, that is, the precise path set is dynamically changed as the test of the test case to be tested proceeds. Accordingly, a detailed description of a specific process of dynamic generation of the precise path set is described below.

In an embodiment, before acquiring the service flow path of the test case to be tested, the method includes:

acquiring a use case set of a tested system where a to-be-tested use case is located;

and acquiring a service circulation path set of the tested system where the test case is located.

In this embodiment, the test executor performs a test on each service circulation path of each use case in the tested system to cover the tested system in whole, so as to obtain a set of use cases and a set of service circulation paths of the tested system.

acquiring each service circulation path in a tested system where a test case to be tested is located;

acquiring each test case to be tested in the tested system;

and associating each test case to be tested with the corresponding service circulation path.

In this embodiment, the test executor obtains each service circulation path from the service circulation path set of the tested system, and obtains each test case from the use case set of the tested system. Each test case to be tested is associated with the corresponding service circulation path, so that the mapping relation between the test case to be tested and the service circulation path is obtained, and all the service circulation paths of the test case can be tested when a single case is tested.

recording the service circulation path which is tested and covered by the tested system through a hook;

and comparing the service circulation paths associated with the test cases to be tested with the service circulation paths which are tested and covered by the tested system, and summarizing the service circulation paths which are not tested and covered by the test cases to be tested into the accurate path set of the test cases to be tested.

In this embodiment, the test executor performs real-time recording on the service circulation path covered by the test by presetting a hook. And each time the test executor tests one service circulation path of the use case, and then selects another service circulation path of the use case for testing, the test executor gathers the service circulation paths which are not covered by the use case into a precise path set of the use case by comparing the tested covered service circulation paths with all service circulation paths associated with the use case.

The embodiment has the advantages that the hooks are used for recording the tested and covered business circulation paths of the tested system in real time, so that the accurate path set of the test case to be tested can be dynamically generated.

In an embodiment, the service flow paths of the test case under test that are not covered by the test case include newly generated service flow paths.

Since the system under test is dynamic, the change of the partial function nodes may cause a new traffic flow path to be generated. The part of the newly generated service circulation paths are not in the service circulation path set of the tested system when the test is started. In this embodiment, whenever a newly generated service circulation path occurs, the newly generated service circulation path is to be supplemented to the accurate path set of the corresponding test case to be tested, so as to ensure the full coverage of the service circulation path of the test case test.

The embodiment has the advantage that the dynamic overall coverage of the service circulation path in the case test process is ensured by timely supplementing the newly generated service circulation path.

In an embodiment, the recording, by the hook, the service circulation path of the tested coverage of the tested system includes:

address replacement is executed when the tested system is started, and an original application programming interface of the tested system is replaced by a hook corresponding to a corresponding application programming interface prototype;

recording function nodes triggered by a tested system and time information during use case testing through hooks;

And generating a service circulation path which is tested and covered by the tested system based on the triggered function node and time information.

As can be seen from the above description of the generation of the library of hooks, each hook in the library of hooks may perform the function of a corresponding application programming interface prototype, since each hook has the same definition as the corresponding application programming interface prototype. That is, the application programming interface derived from the application programming interface prototype can be replaced by the corresponding hook, and the hook controls the information activity of the function node which is controlled by the application programming interface.

In this embodiment, the hook can replace the original application programming interface by replacing the address of the hook, so as to provide services for the corresponding function node, and at the same time, the tested system can be triggered to record the time information of the function node, so as to generate the tested and covered service circulation path of the tested system.

In one embodiment, the address replacement is performed when the tested system is started, including:

address replacement is performed by means of so loading at the start-up of the system under test.

so refers to a dynamically linked library, and correspondingly, performing address replacement by way of so loading in this embodiment refers to performing address replacement by way of dynamically linked library loading.

Through the above detailed description of the generation of the service circulation path set, the generation of the hook library and the generation of the accurate path set, the test scene is directly constructed inside the service circulation path, and the detailed description of the specific process of testing the test case to be tested is further performed.

In step 310, a service flow path of the test case to be tested is obtained.

In one embodiment, the test executor sequentially selects a test case to be tested from the case set of the tested system for testing. And testing one service circulation path of the test case each time until all service circulation paths of the test case are tested, and testing the next test case in the case set until all test cases in the case set are tested.

The specific implementation process of this embodiment has been described in the process of generating the service flow path set, so that the description thereof will not be repeated here.

acquiring each test case to be tested in the tested system;

The implementation process of this embodiment has been described in the process of generating the precise path set, and will not be described herein.

In an embodiment, the obtaining the service circulation path of the test case to be tested includes:

and acquiring a service circulation path according to the service circulation path identifier associated with the test case to be tested.

The service circulation path identifier refers to information capable of uniquely identifying the service circulation path. For example: the function node of the traffic flow path invokes the sequence. If a service flow path is executed by calling function B by function a, calling function C by function B, and calling function D again by function C, the identification of the service flow path may be "a/B/C/D".

In this embodiment, the use case and the corresponding service circulation path establish association and mapping, and correspondingly, the service circulation path identifier is stored in association with the corresponding use case.

In an embodiment, the storing the service circulation path identifier in association with the corresponding application case includes:

and establishing a use case-path mapping table, wherein each use case and a service circulation path identifier associated with the use case are stored in the use case-path mapping table.

In this embodiment, the test executor may obtain each service circulation path identifier associated with the test case by querying the case-path mapping table, so as to obtain a corresponding service circulation path.

The embodiment has the advantages that the case-path mapping table is pre-established, and the service circulation path of the to-be-tested case can be rapidly acquired through table lookup.

and acquiring a service circulation path of the case from the accurate path set of the case to be tested.

In this embodiment, the test executor selects a service circulation path from the precise path set of the test case to be tested each time for testing.

The generation process of the precise path set has been described in the above description, and thus will not be described in detail herein.

In step 320, a test scenario is constructed inside the traffic flow path.

In an embodiment, constructing a test scenario inside a traffic flow path refers to constructing a test scenario inside a traffic flow path in a precise path set.

In an embodiment, the constructing a test scenario inside the service circulation path includes:

and constructing all test scenes which can be guided by the function nodes aiming at each function node in the service circulation path.

Each function node in the traffic flow path typically has a plurality of return values, each of which can be regarded as a branch of the function node, which can then lead to a corresponding test scenario.

In this embodiment, the test executor checks each function node in the service flow path, and constructs all test scenarios that the function node can guide accordingly according to branches that may exist in the function node.

The embodiment has the advantages that the structure of the test scene is carried out aiming at each function node, the granularity of the structure of the test scene is reduced, and the coverage rate of the test scene is improved.

The specific implementation process of this embodiment has been described in the above procedure of generating the hook library, and will not be described herein.

In an embodiment, the constructing all test scenarios that the function node can guide includes:

replacing an original application programming interface for controlling the function node with a hook corresponding to an application programming interface prototype corresponding to the original application programming interface;

constructing all test scenes which can be guided by the function node through the hook.

The original application programming interface refers to the original application programming interface of the tested system.

The information activity of the function nodes is controlled by each application programming interface in the computer system. The hook corresponding to the original application programming interface prototype is replaced by the hook corresponding to the original application programming interface, so that the hook can acquire the control right of the function node.

The test executor processes the call of the original application programming interface through the hook. Since the original application programming interface is replaced by the corresponding hook, call control of the function node by the original application programming interface will be handled by the corresponding hook. If the test executor does not interfere with the information activity of the function node, the hook provides corresponding service for the function node like an original application programming interface; if the test executor decides to interfere the information activity of the function node, the hook is used for correspondingly controlling the information activity of the function node.

An advantage of this embodiment is that the hooks replace the original application programming interface, enabling the test executor to monitor the information activity of each function node in the system under test in real time through the hooks.

In an embodiment, the hooks are composed of a master hook located outside the tested system and a proxy hook located in the tested system, and the master hook controls the action execution of the proxy hook.

In an embodiment, the replacing the original application programming interface for controlling the function node with the hook corresponding to the application programming interface prototype corresponding to the original application programming interface includes:

And replacing the original application programming interface for controlling the function node with a proxy hook corresponding to an application programming interface prototype corresponding to the original application programming interface.

In this embodiment, since the proxy hook directly performs the control action in the system under test, the proxy hook is used instead of the original application programming interface in the system under test.

In an embodiment, the constructing all test scenarios that the function node can guide through the hook includes:

and constructing all test scenes which can be guided by the function node by controlling the proxy hook through the master control hook.

In the embodiment, the test executor issues an instruction to the proxy hook in the tested system through the main control hook, so that the proxy hook is controlled to construct a test scene.

In the embodiment of the disclosure, the proxy hook runs in the tested system in an independent thread, and the construction of the test scene is executed according to the instruction from the main control hook.

Because the proxy hook operates in the tested system by an independent thread, that is, the influence range of the test scene structure of the proxy hook in the service flow path is limited in the thread, and no influence is caused to other processes of the tested system.

In the prior art, the influence range of the test scene structure outside the service circulation path is the whole tested system. In this case, as the use case test proceeds and the test scene is constructed, the stability of the system under test will be greatly reduced, especially when an abnormal test scene needs to be constructed. For example: in the prior art, if an abnormal test scene of "disk space is full" needs to be constructed in the use case test process, a tester can only construct an abnormal tested system environment of "disk space is full" outside the service circulation path. This can result in the disk space of the system under test becoming truly full, thereby affecting the operation of other processes of the system under test and possibly even causing the system under test to crash.

In the embodiment of the disclosure, the test scene is constructed in the service circulation path through the proxy hook of the independent thread. If an abnormal test scene of 'full disk space' needs to be constructed in the use case test process, the test executor can construct the abnormal test scene of 'full disk space' only by transmitting the parameter of 'full disk space' to the corresponding function node through the proxy hook, the operation of other processes of the tested system is not influenced, and the stability of the tested system is ensured.

Meanwhile, in the prior art, the construction of the test scene outside the service circulation path generally involves the change of the environment of the tested system, which results in difficulty in construction, low efficiency and difficulty in large-scale development. In the embodiment of the disclosure, the proxy hook with the independent thread is used for constructing the test scene in the traffic flow path, so that the environment of the tested system is not required to be changed, the construction difficulty is low, the efficiency is high, and the large-scale development is easy.

Further, in practical system testing, the difficulty of testing is mainly focused on two aspects: firstly, the tested system uses a large number of system functions or standard library functions to complete functions such as memory management, disk reading and writing, network communication and the like, and the abnormal conditions of the functions are tested; secondly, the tested system has a plurality of conditions branches, abnormal branches, concurrent time sequences and other scenes which are potentially difficult to cover. In the prior art, a test scene is constructed from outside, so that the construction is difficult, the efficiency is low, the coverage rate is low, and the calling of other processes or other functions of the current process in a tested system is often influenced.

According to the embodiment of the disclosure, the information activities among all function nodes in the service circulation path of the tested system are monitored and intercepted through the hooks, the test scene is constructed with the accuracy of the function level, the automatic construction of the test scene is realized, the construction flow of the test scene is simplified, and the coverage rate of the test scene is improved; because the test scene is constructed in the service circulation path, the test scene is constructed on the function node level of the computer system, thereby enhancing the reusability of the test scene; meanwhile, compared with the prior art, the granularity of the structure is smaller, so that more potential abnormal scenes and concurrent time sequence problems in the tested system can be found, and the tested system is tested more comprehensively.

In the embodiment of the disclosure, the master control hook can perform custom processing on each function node based on the rule file of the custom extension.

The flexibility of processing function nodes by the main control hooks in the test executor is improved through the custom extended rule file.

In step 330, the test case to be tested is tested according to the test scenario.

In the embodiment of the disclosure, after the test executor constructs a test scene in the service circulation path, the tested system operates the corresponding test scene according to the test scene constructed by the test executor, and returns the operation result to the test executor. The test executor analyzes the operation result to obtain a test result.

In one embodiment, for the service flow path of "refund to bank card", the service flow of the service flow path is "receive refund amount- > check refund amount- > refund". The business process node of checking refund amount is realized by the function C-function A-function B at the computer system level.

In the prior art, when constructing a test scene for the service flow path, only the branches of the service flow node can be considered: constructing a corresponding test scene for the branch of checking refund amount, wherein the refund amount exceeds the balance; and constructing a corresponding test scene for the branch of checking refund amount, wherein the refund amount does not exceed the balance.

While the present disclosure considers branches that each function may appear: a respective test scenario is constructed for each return value of function C, a respective test scenario is constructed for each return value of function a, and a respective test scenario is constructed for each return value of function B.

As can be seen from the above description, the test executor in the present disclosure constructs a test scenario by constructing the test scenario inside the service circulation path, that is, by considering each function node in the service circulation path, constructs a test scenario that each function node can guide, compared with the prior art that only the consideration can be performed from the service flow node level to construct the test scenario, the granularity of the test scenario structure is reduced, and the coverage rate of the test scenario is improved.

There is also provided, in accordance with an embodiment of the present disclosure, as shown in fig. 6, a use case testing apparatus, including:

an obtaining module 410, configured to obtain a service circulation path of a test case to be tested;

a construction module 420, configured to construct a test scenario inside the service circulation path;

and the test module 430 is configured to test the test case to be tested according to the test scenario.

In an exemplary embodiment of the present disclosure, the constructing module 420 is further configured to construct, for each function node in the traffic flow path, all test scenarios that the function node can guide.

In an exemplary embodiment of the present disclosure, before the constructing module 420, further includes:

the interface prototype acquisition module is used for acquiring an application programming interface prototype in the tested system where the test case to be tested is located;

and the hook construction module is used for constructing hooks which are defined in the same way as the application programming interface prototypes for each application programming interface prototype.

In an exemplary embodiment of the present disclosure, the construction module 420 further includes:

the replacing module is used for replacing an original application programming interface for controlling the function node with a hook corresponding to an application programming interface prototype corresponding to the original application programming interface;

and the function node construction module is used for constructing all test scenes which can be guided by the function node through the hook.

In an exemplary embodiment of the present disclosure, the hooks are composed of a master hook located outside the tested system and a proxy hook located in the tested system, and the master hook controls the action execution of the proxy hook.

In an exemplary embodiment of the present disclosure, the replacing module is further configured to replace an original application programming interface for controlling the function node with a proxy hook corresponding to an application programming interface prototype corresponding to the original application programming interface.

In an exemplary embodiment of the present disclosure, the pair of function node constructing module is further configured to control, by using a master hook, all test scenarios that the proxy hook can direct to the function node.

In an exemplary embodiment of the present disclosure, before the obtaining module 410 further includes:

the method prototype acquisition module is used for acquiring a business method prototype of the tested system where the test case to be tested is located;

the function call chain acquisition module is used for acquiring a function call chain of the tested system where the test case to be tested is located;

the first path acquisition module is used for acquiring each service circulation path in the tested system based on the service method prototype and the function call chain.

the second path acquisition module is used for acquiring each service circulation path in the tested system where the test case to be tested is located;

The test case acquisition module is used for acquiring each test case to be tested in the tested system;

and the association module is used for associating each test case to be tested with the corresponding service circulation path.

The use case testing method of the embodiments of the present disclosure may be implemented by the test executor 10 shown in fig. 1. A test actuator 10 according to an embodiment of the present disclosure is described below with reference to fig. 7. The test actuator 10 shown in fig. 7 is merely an example and should not be construed as limiting the functionality and scope of use of the disclosed embodiments.

As shown in fig. 7, the test executor 10 is in the form of a general purpose computing device. Components of test executor 10 may include, but are not limited to: the at least one processing unit 510, the at least one memory unit 520, and a bus 530 connecting the various system components, including the memory unit 520 and the processing unit 510.

Wherein the storage unit stores program code that is executable by the processing unit 510 such that the processing unit 510 performs the steps according to various exemplary embodiments of the present invention described in the description of the exemplary methods described above in this specification. For example, the processing unit 510 may perform the various steps as shown in fig. 3.

The storage unit 520 may include readable media in the form of volatile storage units, such as Random Access Memory (RAM) 5201 and/or cache memory unit 5202, and may further include Read Only Memory (ROM) 5203.

The storage unit 520 may also include a program/utility 5204 having a set (at least one) of program modules 5205, such program modules 5205 including, but not limited to: an operating system, one or more application programs, other program modules, and program data, each or some combination of which may include an implementation of a network environment.

Bus 530 may be one or more of several types of bus structures including a memory unit bus or memory unit controller, a peripheral bus, an accelerated graphics port, a processing unit, or a local bus using any of a variety of bus architectures.

The test executor 10 may also communicate with one or more external devices 600 (e.g., keyboard, pointing device, bluetooth device, etc.), one or more devices that enable a user to interact with the test executor 10, and/or any device (e.g., router, modem, etc.) that enables the test executor 10 to communicate with one or more other computing devices. Such communication may occur through an input/output (I/O) interface 550. Also, the test executor 10 may also communicate with one or more networks (e.g., a Local Area Network (LAN), a Wide Area Network (WAN) and/or a public network, such as the Internet) through a network adapter 560. As shown, network adapter 560 communicates with other modules of test executor 10 via bus 530. It should be appreciated that although not shown, other hardware and/or software modules may be used in connection with test executor 10, including, but not limited to: microcode, device drivers, redundant processing units, external disk drive arrays, RAID systems, tape drives, data backup storage systems, and the like.

From the above description of embodiments, those skilled in the art will readily appreciate that the example embodiments described herein may be implemented in software, or may be implemented in software in combination with the necessary hardware. Thus, the technical solution according to the embodiments of the present disclosure may be embodied in the form of a software product, which may be stored in a non-volatile storage medium (may be a CD-ROM, a U-disk, a mobile hard disk, etc.) or on a network, including several instructions to cause a computing device (may be a personal computer, a server, a terminal device, or a network device, etc.) to perform the method according to the embodiments of the present disclosure.

In an exemplary embodiment of the present disclosure, there is also provided a computer program medium having stored thereon computer readable instructions, which when executed by a processor of a computer, cause the computer to perform the method described in the method embodiment section above.

According to an embodiment of the present disclosure, there is also provided a program product for implementing the method in the above method embodiments, which may employ a portable compact disc read only memory (CD-ROM) and comprise program code, and may be run on a terminal device, such as a personal computer. However, the program product of the present invention is not limited thereto, and in this document, a readable storage medium may be any tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device.

The program product may employ any combination of one or more readable media. The readable medium may be a readable signal medium or a readable storage medium. The readable storage medium can be, for example, but is not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or a combination of any of the foregoing. More specific examples (a non-exhaustive list) of the readable storage medium would include the following: an electrical connection having one or more wires, a portable disk, a hard disk, a random access memory (RGM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing.

The computer readable signal medium may include a data signal propagated in baseband or as part of a carrier wave with readable program code embodied therein. Such a propagated data signal may take any of a variety of forms, including, but not limited to, electro-magnetic, optical, or any suitable combination of the foregoing. A readable signal medium may also be any readable medium that is not a readable storage medium and that can communicate, propagate, or transport a program for use by or in connection with an instruction execution system, apparatus, or device.

Program code embodied on a readable medium may be transmitted using any appropriate medium, including but not limited to wireless, wireline, optical fiber cable, RF, etc., or any suitable combination of the foregoing.

Program code for carrying out operations of the present invention may be written in any combination of one or more programming languages, including an object oriented programming language such as JGvG, c++ or the like and conventional procedural programming languages, such as the "C" programming language or similar programming languages. The program code may execute entirely on the user's computing device, partly on the user's device, as a stand-alone software package, partly on the user's computing device, partly on a remote computing device, or entirely on the remote computing device or server. In the case of remote computing devices, the remote computing device may be connected to the user computing device through any kind of network, including a local area network (KGN) or a wide area network (WGN), or may be connected to an external computing device (e.g., connected over the internet using an internet service provider).

It should be noted that although in the above detailed description several modules or units of a device for action execution are mentioned, such a division is not mandatory. Indeed, the features and functionality of two or more modules or units described above may be embodied in one module or unit in accordance with embodiments of the present disclosure. Conversely, the features and functions of one module or unit described above may be further divided into a plurality of modules or units to be embodied.

Furthermore, although the steps of the methods in the present disclosure are depicted in a particular order in the drawings, this does not require or imply that the steps must be performed in that particular order or that all illustrated steps be performed in order to achieve desirable results. Additionally or alternatively, certain steps may be omitted, multiple steps combined into one step to perform, and/or one step decomposed into multiple steps to perform, etc.

From the above description of embodiments, those skilled in the art will readily appreciate that the example embodiments described herein may be implemented in software, or may be implemented in software in combination with the necessary hardware. Thus, the technical solution according to the embodiments of the present disclosure may be embodied in the form of a software product, which may be stored in a non-volatile storage medium (may be a CD-ROM, a U-disk, a mobile hard disk, etc.) or on a network, including several instructions to cause a computing device (may be a personal computer, a server, a mobile terminal, or a network device, etc.) to perform the method according to the embodiments of the present disclosure.

Other embodiments of the disclosure will be apparent to those skilled in the art from consideration of the specification and practice of the disclosure disclosed herein. This application is intended to cover any adaptations, uses, or adaptations of the disclosure following, in general, the principles of the disclosure and including such departures from the present disclosure as come within known or customary practice within the art to which the disclosure pertains. It is intended that the specification and examples be considered as exemplary only, with a true scope and spirit of the disclosure being indicated by the following claims.

Claims

1. A use case testing method, the method comprising:

acquiring a service circulation path of a test case to be tested;

for each function node in a service flow path, replacing an original application programming interface for controlling the function node with a proxy hook corresponding to an application programming interface prototype corresponding to the original application programming interface; the proxy hook is positioned in the tested system and is responsible for monitoring and intercepting information activities of a service circulation path in the tested system, and directly controlling the construction of a test scene in the service circulation path;

constructing all test scenes which can be guided by the function node through the proxy hook;

and testing the test case to be tested according to the test scene.

2. The method of claim 1, comprising, prior to replacing an original application programming interface for controlling the function node with a proxy hook corresponding to an application programming interface prototype corresponding to the original application programming interface:

for each application programming interface prototype, constructing hooks defined identically to the application programming interface prototype, the hooks including the proxy hooks.

3. The method of claim 2, wherein the hooks consist of master hooks located outside the system under test and proxy hooks located in the system under test, the master hooks controlling the execution of actions by the proxy hooks.

4. A method according to claim 3, wherein constructing all test scenarios that the function node can direct by the proxy hook comprises:

and controlling the proxy hook to construct all test scenes which can be guided by the function node through the main control hook.

5. The method of claim 1, comprising, prior to replacing an original application programming interface for controlling the function node with a proxy hook corresponding to an application programming interface prototype corresponding to the original application programming interface:

6. The method of claim 1, comprising, prior to the obtaining the service flow path of the test case under test:

acquiring each test case to be tested in the tested system;

7. The utility model provides a use case test terminal which characterized in that includes:

the construction module is used for replacing an original application programming interface for controlling each function node in the service circulation path with a proxy hook corresponding to an application programming interface prototype corresponding to the original application programming interface; constructing all test scenes which can be guided by the function node through the proxy hook; the proxy hook is positioned in the tested system and is responsible for monitoring and intercepting information activities of a service circulation path in the tested system, and directly controlling the construction of a test scene in the service circulation path;