CN112445692A

CN112445692A - Case testing method and terminal

Info

Publication number: CN112445692A
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: 2021-03-05
Anticipated expiration: 2039-08-27
Also published as: CN112445692B

Abstract

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

Description

Case testing method and terminal

Technical Field

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

Background

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

In the prior art, a test scenario is firstly constructed outside a service flow path of a use case, and then the use case is tested according to the externally constructed test scenario. The test scene constructed by the method can not completely 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 use case, so as to improve the coverage of a test scenario of the use case test.

According to an aspect of the embodiments of the present disclosure, a method for testing a use case is disclosed, the method including:

acquiring a service flow path of a case to be tested;

constructing a test scene in a service circulation path;

and testing the cases 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 includes:

the acquisition module is used for acquiring a service flow path of a use 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 to-be-tested case according to the test scene.

In the prior art, a test scenario is constructed outside a service flow path of a case to be tested, that is, a test scenario is constructed by considering branches possibly occurring in the service flow path from a service flow node level. Therefore, the grain fineness of the test scene structure in the prior art is stopped at the level of the service flow nodes, and the coverage rate of the test scene is low. When the use case test is carried out, the test scene is constructed in the service flow path of the use case to be tested, namely, the possible branches of the service flow path are considered from the function node level of the computer system, and then the test scene is constructed. Therefore, the test scene can be constructed with smaller granularity, and the test scene coverage rate of case test is improved.

Additional features and advantages of the disclosure will be set forth in the detailed description which follows, or in part will be obvious from the description, or may be learned by 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 architectural diagram of a use case testing method according to one embodiment of the present disclosure.

Fig. 2 shows a schematic diagram of an internal structure of a traffic flow path according to an embodiment of the present disclosure.

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

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

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

FIG. 6 illustrates a block diagram of a use case test terminal according to one embodiment of the present disclosure.

FIG. 7 illustrates a hardware block diagram of a use case test terminal according to one embodiment of the present disclosure.

Detailed Description

Example embodiments will now be described more fully with reference to the accompanying drawings. Example embodiments may, however, be embodied in many different 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 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 their repetitive description 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 subject matter of the present disclosure can be practiced without one or more of the specific details, or with other methods, components, steps, and so forth. 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 the form of 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 with reference first to FIG. 1.

FIG. 1 illustrates the entities involved in the architecture of an embodiment of the present disclosure: the test executor 10 and the system under test 20. The test executor 10 controls the structure of the test scene of the to-be-tested case, and the tested system 20 runs the test scene of the test executor 10, so as to obtain a running result and realize the test of the to-be-tested case.

Specifically, the test executor 10 obtains a service circulation path of a case to be tested in the system 20 to be tested, and constructs a test scene in the service circulation path; further, the tested system 20 runs the test executor 10 on the test scene constructed in the service circulation path to obtain a running result; further, the test executor 10 obtains a test result of the to-be-tested case through analysis of the operation result, so as to test the to-be-tested case.

Fig. 2 illustrates the internal structure of a traffic flow path in one embodiment. In this embodiment, for a service flow path of a use case to be tested, the execution of the service flow path is performed according to the sequence that 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 captures information activities between function nodes by setting hooks. And the test executor can correspondingly construct a test scene at the hook interception point according to a preset test scene rule every time the interception is executed.

It should be noted that the embodiment is only exemplary and should not limit the function and scope of the disclosure.

Before describing the embodiments of the present disclosure in detail, the logic structure of one embodiment of the present disclosure will be briefly described with reference to fig. 3 and 4 in order to more fully illustrate the implementation of the embodiments of the present disclosure.

Fig. 3 shows the entities involved in an embodiment of the present disclosure, as well as the main logical structural components. The embodiments relate to entities that are: testing an actuator and a tested system; the main logic structure components involved are: the system comprises a service circulation path set, an accurate path set, a master control hook, an agent hook and a test scene rule.

Specifically, in the computer system, the service flow path is embodied as a function call link executed by the system to be tested, as shown in fig. 2.

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

The service flow path set refers to a set of all paths that may be executed when the tested system performs service flow.

For example: all possible paths executed by the tested system during the business circulation are 'refund to WeChat balance', 'refund to Bank card', 'transfer to WeChat balance' and 'transfer to Bank card'. The set of the business circulation paths of the tested system is — - [ refund to WeChat balance ] -, [ refund to Bank card ] -, [ transfer to WeChat balance ] -, and [ transfer to Bank card ].

The accurate path set refers to a service flow path of a specific use case of the tested system, which is not tested by the current time point of test in the process of testing the use case.

For example: in the tested system, all the business circulation paths of the use case of 'refund' include 'refund to WeChat balance' and 'refund to bank card'. By the current time point of the test, the service flow path from refund to WeChat balance is already tested, the service flow path of the case which is not tested is from refund to bank card, and the precise path of the case at the current time point is integrated as- (refund to bank card').

The Master Hook (i.e., Hook Master) and the proxy Hook (i.e., Hook Agent) belong to the same Hook (i.e., Hook). A hook is a program that can monitor and intercept information activities. After the hook intercepts the information activity, the hook can replace the original function node which is responsible for processing the information activity, and then the information activity is subsequently controlled.

In the embodiment of the disclosure, the proxy hook is located inside the system to be tested and is responsible for monitoring and intercepting information activities of a service circulation path inside the system to be tested and directly controlling a test scene structure inside 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 agent hook, and the information activity monitoring and intercepting conditions of the agent hook on the service circulation path in the tested system can be obtained in real time; and the test executor sends an instruction related to the construction of the test scene to the main control hook, so that the control agent hook constructs the test scene in the service flow transfer path.

The test scenario rule is a rule for constructing a test scenario in the service flow path, and can be preset by a tester.

Specifically, after reading the service circulation path set and the accurate path set, the test executor controls the proxy hook through the master hook according to the test scenario rule and the information activity condition of the service circulation path in the tested system, and correspondingly constructs a test scenario 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: the method comprises the steps of testing execution logic, a service circulation path set, an accurate path set, a hook library, a master hook and an agent hook and testing scene rules.

The test execution logic refers to a set of execution logic followed in the whole process when the test executor tests the use case. The test execution logic is written into the test executor by a tester in advance, so that the test executor can execute the embodiment of the disclosure according to the test execution logic.

The test executor performs 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 flow path set.

The test executor performs code preprocessing on the agent source file in the tested system, can acquire a system application programming interface prototype and a service application programming interface prototype of the tested system in addition to acquiring a function call chain of the tested system, and further generates a hook library for the tested system. The hooks in the hook library can monitor and capture information activities between function nodes in a service flow path (specifically, a service flow path embodied as a function call chain in a computer system), and further construct a test scene in the service flow path. Specifically, the agent hook monitors and intercepts information activities among function nodes in the service flow path, and the main control hook controls the agent hook to construct a test scene in the service flow path.

And the test executor associates 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 covered by the test of the currently tested case with the corresponding service circulation paths mapped by the case, so as to obtain an accurate path set of the case at the current time point.

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

It should be noted that the embodiment is merely an exemplary brief description of an embodiment of the disclosure, and is intended to show the general composition and general flow of an embodiment of the disclosure in the practical implementation process, and should not limit the function and scope of the disclosure.

A detailed implementation of an embodiment of the present disclosure is described below with reference to fig. 5.

An execution subject of the embodiment of the present disclosure is the test executor shown in fig. 1, and as shown in fig. 5, a case testing method includes:

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

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

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

When the test case to be tested is tested, the test scene is constructed in each service flow path aiming at each service flow path of the case to be tested, and then the 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 is to test each use case in the system under test. The test executor tests each case in the system under test as a case to be tested according to the flow shown in fig. 5.

Therefore, before the test is performed on the to-be-tested sample, specifically, before the service flow path of the to-be-tested sample is acquired, the service flow path set of the to-be-tested system needs to be generated. A detailed description of the specific implementation process of generating the traffic flow path set is described below with reference to fig. 4.

In an embodiment, before the obtaining of the traffic flow path of the use case to be tested, the method includes:

acquiring a business method prototype of a tested system where a to-be-tested case is;

acquiring a function call chain of a tested system where a use case to be tested is located;

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

A business method prototype refers to a null object that can be instantiated into a specific business method, and the business method prototype can derive a plurality of specific business methods.

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

Through the combination between the service method prototype and the function call chain, a function node link, i.e., a service flow path, describing the service flow process can be obtained. A first rating: the service flow path is regarded as a building capable of realizing specific functions, the service method prototype is regarded as an instructive manual describing the building with specific functions to be built, the function call chain is regarded as a blueprint describing how to connect various basic building materials under various conditions, and the function node is regarded as a basic building material. And 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 this embodiment, the test executor obtains a service method prototype of the tested system where the to-be-tested case is located and the function call chain, and combines the function nodes according to the function call chain according to the service method prototype, thereby obtaining each service flow path in the tested system, that is, obtaining a service flow path set of the tested system.

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

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

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

and traversing the syntax tree of the tested system to obtain a business 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 system under test, and specifically, performs compilation front-end processing on the code source file of the system under test to obtain a syntax tree of the system under test. And traversing the syntax tree of the tested system to obtain each service 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 syntax tree of the tested system.

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

and traversing the syntax tree according to a depth-first search algorithm in a recursive 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 a graph, traversing nodes of the tree along the depth of the tree, searching branches of the tree as deep as possible, and belongs to blind search.

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

and traversing the syntax tree of the tested system to obtain a function call chain of the tested system.

This embodiment has the advantage 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 an embodiment, the traversing the syntax tree of the system under test to obtain the function call chain of the system under test includes:

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

In an embodiment, the test executor implements test scenario construction inside the service circulation path through a hook. The service circulation path can involve various function nodes, and for different types of function nodes, different hooks are needed to be used for monitoring and intercepting the function nodes.

Therefore, before the test is performed on the sample to be tested, specifically, before the service flow path of the sample to be tested is acquired, a hook library for monitoring and intercepting each function node in the service flow path needs to be generated. The specific implementation of the hook library generation is described in detail below with reference to fig. 4.

In an embodiment, before the constructing the test scenario inside the traffic flow path, the method includes:

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

for each application programming interface prototype, constructing a hook with the same definition as the application programming interface prototype.

An application programming interface prototype refers to a null object that can be instantiated into a particular application programming interface, and the application programming interface prototype can derive a plurality of application programming interfaces.

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

In this embodiment, the test executor acquires each application programming interface prototype from the tested system in which the use case to be tested is located, and constructs a hook having the same definition as the application programming interface prototype for each application programming interface prototype, thereby obtaining a hooked library.

The embodiment has the advantage that the hook can replace the application programming interface derived from each application programming interface prototype by generating the hook with the same definition as each application programming interface prototype, so that each function node can be controlled.

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

extracting a system application programming interface prototype of the tested system based on the 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 the basic operation function related function of the system, and correspondingly, the system application programming interface prototype refers to a prototype of the application programming interface for controlling the basic operation function related function of the system.

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 correspondingly, the prototype of the service application programming interface refers to a prototype of the application programming interface for controlling the function related to the service flow function of the system.

In the embodiment, the test executor acquires an official application programming interface document of the system to be tested, extracts a system application programming interface prototype and a business application programming interface prototype of the system to be tested on the basis, and constructs hooks with the same definition for each application programming interface prototype.

In an embodiment, when the test executor tests the use case to be tested, the test executor tests a service circulation path selected from the accurate path set of the use case. As can be seen from the above description, the accurate path set refers to a set of service flow paths that the test case to be tested has not been covered by the test, that is, the accurate path set is dynamically changed as the test on the test case to be tested is performed. Therefore, a detailed description of the specific process of dynamic generation of the precise path set is provided below.

In an embodiment, before obtaining a traffic flow path of a use case to be tested, the method includes:

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

and acquiring a service flow path set of a tested system where the to-be-tested case is located.

In this embodiment, the test executor is to execute a test on each service circulation path of each use case in the tested system to fully cover the tested system, so as to obtain a use case set and a service circulation path set of the tested system.

acquiring each service flow path in a tested system where a use case to be tested is located;

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

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

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

recording the tested and covered service circulation path of the tested system through the hook;

and comparing the service flow path associated with the case to be tested with the service flow path tested and covered by the tested system, and summarizing the service flow paths not tested and covered by the case to be tested into an accurate path set of the case to be tested.

In this embodiment, the test executor records the traffic flow forwarding path covered by the test in real time by presetting a hook. When the test executor finishes testing one service flow path of the case and selects another service flow path of the case for testing, the test executor summarizes the service flow paths which are not tested and covered by the standby case into an accurate path set of the case by comparing the service flow paths which are tested and covered with the test and all the service flow paths related to the case.

The embodiment has the advantage that the hook is used for recording the traffic flow switching path which is tested and covered by the tested system in real time, so that the accurate path set of the use case to be tested can be dynamically generated.

In one embodiment, the traffic flow path covered by the untested case to be tested comprises a newly generated traffic flow path.

Because the system under test is dynamic, changes in the partial function nodes may cause new traffic flow paths to be generated accordingly. The newly generated part of the service circulation path is not in the service circulation path set of the tested system at the test starting time. In this embodiment, each time a newly generated service circulation path occurs, the newly generated service circulation path is supplemented to the accurate path set of the corresponding use case to be tested, so as to ensure the comprehensive coverage of the service circulation path of the use case test.

The embodiment has the advantage that the dynamic and comprehensive coverage of the service circulation path in the use case testing process is ensured by timely supplementing the newly generated service circulation path.

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

executing address replacement when the tested system is started, and replacing an original application programming interface of the tested system with a hook corresponding to a corresponding application programming interface prototype;

recording function nodes and time information triggered by a tested system during a use case test period through a hook;

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

As can be seen from the above description of hook library generation, each hook in the hook library can execute the function of the corresponding application programming interface prototype because 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 controlled by the application programming interface.

In the embodiment, the address of the original application programming interface is replaced by the address of the hook, so that the hook can replace the original application programming interface to provide service for the corresponding function node, and meanwhile, the time information of the function node can be recorded by triggering the system to be tested, and further, a service flow path covered by the system to be tested is generated.

In an embodiment, the performing address replacement when the system under test is started includes:

and performing address replacement in a so loading mode when the tested system is started.

so refers to a dynamic link library, and correspondingly, the address replacement performed by the so loading mode in this embodiment refers to the address replacement performed by the dynamic link library loading mode.

Through the detailed description of the generation of the service flow path set, the generation of the hook library and the generation of the accurate path set, a test scene is directly constructed in the service flow path, and then a specific process of testing a case to be tested is described in detail.

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

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

The specific implementation process of this embodiment has been described in the generation process of the service flow path set, and therefore, is not described herein again.

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

The specific implementation process of this embodiment has been described in the generation process of the precise path set, and therefore, is not described herein again.

In an embodiment, the obtaining a service flow path of a use case to be tested includes:

and acquiring a service flow path according to the service flow path identifier associated with the use case to be tested.

The service flow path identifier is information capable of uniquely identifying a service flow path. For example: and calling sequence of the function nodes of the service flow path. If a service flow path is executed by calling a function B through a function a, calling a function C through the function B, and calling a function D through the function C, the identifier of the service flow path may be "a/B/C/D".

In the embodiment, association and mapping are established between the use cases and the corresponding service circulation paths, and correspondingly, the service circulation path identifications and the corresponding use cases are stored in an associated manner.

In an embodiment, the storing the service flow path identifier and the corresponding use case in association includes:

and establishing a use case-path mapping table, wherein each use case and a service flow 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 flow path identifier associated with the to-be-tested case by querying the case-path mapping table, and further obtain the corresponding service flow path.

The embodiment has the advantages that the use case-path mapping table is established in advance, and the service flow path of the use case to be tested can be quickly acquired through table lookup.

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

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

The generation process of the precise path set has been described in the above description, and therefore is not described herein again.

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

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

In an embodiment, the constructing a test scenario inside a traffic flow path includes:

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

Each function node in the service flow path generally has a plurality of return values, each return value can be regarded as a branch of the function node, and the branch can be directed to a corresponding test scenario.

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

The embodiment has the advantages that the test scene is constructed for each function node, the granularity of the test scene construction is reduced, and the coverage rate of the test scene is improved.

The specific implementation process of this embodiment has been described in the generation process of the hook library, and therefore, is not described herein again.

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

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

and constructing all test scenes which can be guided by the function nodes through the hooks.

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

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

The test executor processes calls of the original application programming interface through the hook. Since the original application programming interface is replaced by the corresponding hook, the call control of the original application programming interface to the function node is 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; and if the test executor determines to interfere with the information activity of the function node, correspondingly controlling the information activity of the function node through the hook.

This embodiment has the advantage that the hook is used to replace the original application programming interface, so that the test executor can monitor the information activity of each function node in the tested system in real time through the hook.

In an embodiment, the hook is composed of a master hook located outside the system under test and an agent hook located in the system under test, and the master hook controls the action execution of the agent hook.

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

and replacing the original application programming interface used for controlling the function node with the proxy hook corresponding to the application programming interface prototype corresponding to the original application programming interface.

In this embodiment, since it is the proxy hook that directly performs the control action in the system under test, the proxy hook is used to replace the original application programming interface in the system under test.

In an embodiment, the constructing, by the hook, all test scenarios to which the function node can be directed includes:

and constructing all test scenes which can be guided by the function nodes through the master hook control agent hook.

In this embodiment, the test executor issues an instruction to an agent hook in the system under test through the master hook, thereby controlling the agent hook to construct a test scenario.

In the embodiment of the disclosure, the agent hook runs in the system under test as an independent thread, and executes the construction of the test scenario according to the instruction from the main control hook.

Because the agent hook runs in the tested system through an independent thread, namely, the influence range of the test scene structure of the agent hook in the service circulation path is limited to the inside of the thread, and no influence is caused on other processes of the tested system.

However, in the prior art, the influence range of the test scene structure outside the service circulation path is the whole system under test. In this case, the stability of the system under test will be greatly reduced along with the progress of the use case test and the construction of the test scenario, especially when an abnormal test scenario needs to be constructed. For example: in the prior art, if an abnormal test scenario of "full disk space" needs to be constructed in the case test process, a tester can only construct an abnormal tested system environment of "full disk space" outside the service flow path. This may cause the disk space of the system under test to become full, thereby affecting the operation of other processes of the system under test, and may even cause the system under test to crash.

In the embodiment of the present disclosure, the test scenario is constructed inside the service circulation path through the proxy hook of the independent thread. If the abnormal test scene of 'full disk space' needs to be constructed in the 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, and the operation of other processes of the tested system is not affected, so that the stability of the tested system is ensured.

Meanwhile, in the prior art, the construction of a test scene outside a service circulation path usually involves the modification of the environment of a system to be tested, which causes the construction difficulty, low efficiency and difficulty in large-scale development. The embodiment of the disclosure constructs the test scene in the service flow transfer path through the agent hook of the independent thread, does not need to change the environment of the system to be tested, and has low construction difficulty, high efficiency and easy large-scale development.

Further, in the actual system test, the difficulty of the test is mainly focused on two aspects: firstly, a 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 abnormal conditions of the functions are tested to be covered; and secondly, the tested system has a plurality of conditions, abnormal branches, concurrent sequences and other scenes which are potentially difficult to cover. In the prior art, a test scene is constructed from the outside, so that the construction is difficult, the efficiency is low, the coverage rate is high, and the calling of other processes in a tested system or other functions of the current process is often influenced.

According to the method and the device, information activities among function nodes in a service circulation path of the tested system are monitored and intercepted through the hook, the test scene is constructed with the function-level accuracy, the automatic construction of the test scene is realized, the construction process 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 reutilization of the test scene; meanwhile, as the granularity of the structure is smaller than that of the prior art, more potential abnormal scenes and concurrency time sequence problems in the tested system can be found, and the tested system is tested more comprehensively.

In the embodiment of the present disclosure, the master hook may perform custom processing on each function node based on a custom extended rule file.

By customizing the expanded rule file, the processing flexibility of the main control hook in the test executor on the function node is improved.

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 the test scenario inside the service flow forwarding path, the system under test runs the corresponding test scenario according to the test scenario constructed by the test executor, and returns the running result to the test executor. And the test executor analyzes the operation result to obtain a test result.

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

In the prior art, when constructing a test scenario for the service flow path, only the branch of the service flow node is considered: for the branch of checking the refund amount, the refund amount exceeds the balance, a corresponding test scene is constructed; for the branch of 'checking refund amount, refund amount not exceeding balance' the corresponding test scenario is constructed.

While the present disclosure considers the branches that each function may appear: and constructing a corresponding test scene for each return value of the function C, constructing a corresponding test scene for each return value of the function A, and constructing a corresponding test scene for each return value of the function B.

As can be seen from the above description, the test executor in the present disclosure constructs a test scenario inside the service flow path, that is, constructs a test scenario that each function node can guide by considering each function node in the service flow path, and compared with the prior art that a test scenario can only be constructed by considering from the service flow node level, reduces the granularity of test scenario construction, and improves the coverage of the test scenario.

According to an embodiment of the present disclosure, as shown in fig. 6, there is also provided a use case testing apparatus, including:

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

a constructing module 420, configured to construct a test scenario inside the service flow path;

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

In an exemplary embodiment of the 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, the method further includes:

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

and the hook construction module is used for constructing hooks with the same definition as the application programming interface prototypes aiming at each application programming interface prototype.

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

the replacing module is used for replacing the original application programming interface used 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 constructing module is used for constructing all test scenes which can be guided by the function nodes through the hooks.

In an exemplary embodiment of the present disclosure, the hook is composed of a master hook located outside the system under test and an agent hook located in the system under test, and the master hook controls the execution of actions of the agent hook.

In an exemplary embodiment of the disclosure, the replacement 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 disclosure, the pair of function nodes constructing module is further configured to construct all test scenarios that the function nodes can guide through the master hook control agent hook.

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

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

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

and the first path acquisition module is used for acquiring each service flow 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 flow path in the tested system where the use case to be tested is located;

the system comprises a to-be-tested case acquisition module, a to-be-tested case acquisition module and a to-be-tested case acquisition module, wherein the to-be-tested case acquisition module is used for acquiring each to-be-tested case in the to-be-tested system;

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

The use case testing method of the embodiment of the present disclosure may be implemented by the test executor 10 shown in fig. 1. A test executor 10 according to an embodiment of the present disclosure is described below with reference to fig. 7. The test executor 10 shown in fig. 7 is only an example and should not bring any limitations to the function and the scope of use of the embodiments of the present disclosure.

As shown in fig. 7, the test executor 10 is in the form of a general purpose computing device. The components of the 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 that couples 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 to cause the processing unit 510 to perform steps according to various exemplary embodiments of the present invention as described in the description part of the above exemplary methods of the present specification. For example, the processing unit 510 may perform the various steps as shown in fig. 3.

The memory unit 520 may include a readable medium in the form of a volatile memory unit, such as a random access memory unit (RAM)5201 and/or a cache memory unit 5202, and may further include a read only memory unit (ROM) 5203.

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 of which, or some combination thereof, may comprise an implementation of a network environment.

Bus 530 may be one or more of any 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.), may also communicate with one or more devices that enable a user to interact with the test executor 10, and/or may communicate with any devices (e.g., router, modem, etc.) that enable the test executor 10 to communicate with one or more other computing devices. Such communication may occur via input/output (I/O) interfaces 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) via a network adapter 560. As shown, the network adapter 560 communicates with the other modules of the test executor 10 through a bus 530. It should be understood that although not shown in the figures, other hardware and/or software modules may be used in conjunction with the test executor 10, including but not limited to: microcode, device drivers, redundant processing units, external disk drive arrays, RAID systems, tape drives, and data backup storage systems, among others.

Through the above description of the embodiments, those skilled in the art will readily understand that the exemplary embodiments described herein may be implemented by software, or by software in combination with necessary hardware. Therefore, 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 (which may be a CD-ROM, a usb disk, a removable hard disk, etc.) or on a network, and includes several instructions to enable a computing device (which may be a personal computer, a server, a terminal device, or a network device, etc.) to execute 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 above method embodiment section.

According to an embodiment of the present disclosure, there is also provided a program product for implementing the method in the above method embodiment, which may employ a portable compact disc read only memory (CD-ROM) and include 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 in this regard and, in the present 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. A readable storage medium may be, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination of the foregoing. More specific examples (a non-exhaustive list) of the readable storage medium include: 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 disk read only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing.

A computer readable signal medium may include a propagated data signal with readable program code embodied therein, for example, in baseband or as part of a carrier wave. Such a propagated data signal may take many forms, including, but not limited to, electro-magnetic, optical, or any suitable combination thereof. 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 for aspects 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 and partly on a remote computing device, or entirely on the remote computing device or server. In the case of a remote computing device, 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., through the internet using an internet service provider).

It should be noted that although in the above detailed description several modules or units of the 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, according to embodiments of the present disclosure. Conversely, the features and functions of one module or unit described above may be further divided into embodiments by a plurality of modules or units.

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

Through the above description of the embodiments, those skilled in the art will readily understand that the exemplary embodiments described herein may be implemented by software, or by software in combination with necessary hardware. Therefore, 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 (which may be a CD-ROM, a usb disk, a removable hard disk, etc.) or on a network, and includes several instructions to enable a computing device (which may be a personal computer, a server, a mobile terminal, or a network device, etc.) to execute 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 variations, 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 method for use case testing, the method comprising:

acquiring a service flow path of a case to be tested;

constructing a test scene in a service circulation path;

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

2. The method of claim 1, wherein constructing the test scenario inside the traffic forwarding path comprises:

3. The method of claim 1, wherein before constructing the test scenario inside the traffic flow path, the method comprises:

4. The method of claim 2, wherein constructing all test scenarios to which the function node can be directed comprises:

5. The method of claim 3, wherein the hook is composed of a master hook located outside the system under test and an agent hook located in the system under test, and wherein the master hook controls execution of actions of the agent hook.

6. The method according to claim 4, wherein replacing the 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 comprises:

7. The method of claim 4, wherein constructing all test scenarios to which the function node can be directed through the hook comprises:

8. The method of claim 1, wherein before the obtaining the traffic flow path of the use case to be tested, the method comprises:

9. The method of claim 1, wherein before the obtaining the traffic flow path of the use case to be tested, the method comprises:

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

10. A use case test terminal, comprising: