CN114741296A

CN114741296A - Unit testing method, unit testing device, electronic equipment and storage medium

Info

Publication number: CN114741296A
Application number: CN202210376644.5A
Authority: CN
Inventors: 李源通
Original assignee: Wuhan Zilan Information Technology Co ltd
Current assignee: Wuhan Zilan Information Technology Co ltd
Priority date: 2022-04-12
Filing date: 2022-04-12
Publication date: 2022-07-12

Abstract

The invention provides a unit testing method, a unit testing device, electronic equipment and a storage medium, wherein the unit testing method comprises the following steps: compiling and storing corresponding test case codes for development cases; pulling the test case code and compiling into FatJar; executing the test case in a FatJar reflection mode; and storing the execution result.

Description

Unit testing method, unit testing device, electronic equipment and storage medium

Technical Field

This document relates to, but is not limited to, the field of testing.

Background

The underlying components are typically very logically complex and require very many tests to ensure quality as much as possible.

In the prior art, the development tester mainly uses the following methods to perform unit testing:

(1) test case compiling based on Junit

The Junit is very powerful in itself and perfectly integrated with spring, and is the first choice for writing unit test in java field. It can only be performed manually within the code and is not well managed. As it is typically written within the current item. Therefore, when a new function is developed and a new code branch is pulled, the test case is generally rewritten. The test cases of the previous version may not be maintained and not available for a long time. In addition, the new project branch generally only tests the characteristics of the current branch, so that the whole test scene is incomplete, and the test quality is difficult to ensure. The positioning is a functional test, so the management and automation aspects are not considered. Especially, with the iteration of versions, functions are more and more, the code complexity is higher and more, and the management of unit testing is more important.

(2) Testing of a unit by code self-writing

The test case is built by the code, so that the method is more flexible and is more suitable for some simple scene tests. But for complex scenario testing, it is extremely difficult and hardly feasible to rely on third-party components. Therefore, the application scenarios are very limited, and the conditions of management, automation and the like are not provided. And the method can be only used for checking some simple functions in the daily development process.

(3)Postman

postman is a tool for simulating http call, and has the capability of storing API call, and the function of this aspect is very powerful, and in addition, it can store the API executed before and its parameters. Therefore, the method has certain management capability, and the functions called by the front end and the back end can be tested through postman. But the use scene is relatively limited for the basic component and can only be used in the field of front-end interaction.

The versions of the base component iterate very quickly, so the prior art has not been able to solve several of the more serious problems:

1. the number of unit test cases is large

2. Unit test case maintenance difficulties

3. Unit test cases are different between different versions

4. Difficulty in regression testing of foundation components

5. Unit test cases are difficult to automate

Quality assurance of the underlying components has been a daunting task. Many times new versions are released and problems that were previously fixed are discovered and are present, or new problems are present. Even the test case written before can not run due to version change, and the history can not be verified. The prior art is not sufficient for some UI ends and some tests related to behaviors or states in the process. In addition, the loading process may be lengthy because it is compiled into FatJar. Therefore, a new testing method is urgently needed.

Disclosure of Invention

The following presents a summary of various exemplary aspects. Some simplifications and omissions may be made in the following summary, which is intended to highlight and introduce some aspects of the various exemplary embodiments, but not to limit the scope of the invention. Detailed descriptions of exemplary embodiments sufficient to enable those of ordinary skill in the art to make and use the inventive concepts will be presented in the following sections.

In order to solve the above technical problem, a technical solution of the present invention provides a unit testing method, including: compiling and storing corresponding test case codes for development cases; pulling the test case code and compiling into FatJar; executing the test case in a FatJar reflection mode; and storing the execution result.

Preferably, the test case code further includes an annotation of at least one of: classification level annotation, method level annotation.

Preferably, the executing the test case by means of reflection by the FatJar further includes: and loading the FatJar into jvm through the custom classloader, and executing the test case in a reflection mode of the class in the FatJar.

Preferably, the method further comprises outputting the execution result to a front end.

Another aspect of the present invention provides a unit testing apparatus, including: the test code compiling module is configured to compile corresponding test case codes for the development cases; the test code management module: configured to store test case code; the test case management module is configured to pull the test case codes from the test code management module, compile the test case codes into FatJar and execute the test cases in a FatJar reflection mode; a database configured to store the execution result.

Preferably, the test code management module is a GitLab.

Preferably, the executing the test case by the reflection of the FatJar includes: FatJar is loaded into jvm through the custom classloader, and the test case is executed through the reflection of the class in FatJar.

Another technical solution of the present invention also provides an electronic device, including: a processor, a memory, and a computer program stored in the memory for execution by the processor, wherein the processor implements the steps of the method according to any of the above aspects when executing the computer program.

Another aspect of the present invention further provides a computer readable storage medium, wherein the computer program is executed by a processor to implement the steps of the method according to any one of the above aspects.

The technical scheme of the invention mainly has the following beneficial effects:

first, the unit test cases may be managed and maintained centrally according to the base component version.

Second, test case sets between different component versions can be automatically executed in parallel.

Third, the history cell test cases and the problem scenarios to be solved by the test cases at the time can be tracked.

Drawings

For a better understanding of various exemplary embodiments, reference may be made to the accompanying drawings in which:

FIG. 1 is a flow chart illustrating a unit testing method according to an embodiment;

fig. 2 shows a schematic structural diagram of a unit testing device provided by the embodiment.

To facilitate understanding, the same reference numerals have been used to designate elements having substantially the same or similar structure and/or substantially the same or similar function.

Detailed Description

The description and drawings illustrate the principles of the invention. It will thus be appreciated that those skilled in the art will be able to devise various arrangements which, although not explicitly described or shown herein, embody the principles of the invention and are included within its scope. Moreover, all examples cited herein are principally intended expressly to be only for pedagogical purposes to aid the reader in understanding the principles of the invention and the concepts contributed by the inventor to furthering the art, and are to be construed as being without limitation to such specifically cited examples and conditions. Further, as used herein, the term "or" refers to a non-exclusive or (i.e., and/or) unless otherwise indicated (e.g., "or otherwise" or in the alternative). Moreover, the various embodiments described herein are not necessarily mutually exclusive, as some embodiments may be combined with one or more other embodiments to form new embodiments.

The noun explains:

JUnit is an open source Java test framework for writing and running repeatable tests. It is an example for the Unit test framework xUnit (for the java language). It includes the following characteristics: 1. assertion (Assertion) for testing the expected result; 2. a test tool for sharing common test data; 3. a test kit for convenient organization and running of tests; 4. test runner for graphics and text

GitLab is an open source project for a warehouse management system, and is a Web service built on the basis of the code management tool which is used as a code management tool. The installation method is to reference the GitLab Wiki page on GitHub.

Classloader A Classloader class loader is used to load Java classes to a loader in the Java virtual machine.

FatJar is a jar package that contains all project class files and resources and all dependencies.

A first embodiment provides a unit testing method, see fig. 1, comprising:

step S101, compiling and storing corresponding test case codes for development cases;

the application program App application program is provided with a plurality of application program interface APIs, and each API is provided with one to a plurality of corresponding test cases. Each development version corresponds to a test version.

The test code of the unit can be stored separately according to branches by adopting GitLab or other suitable code management tools (GitLab is taken as an example hereinafter), one branch corresponds to one version release or one development branch is established first for large characteristic improvement, a corresponding test branch is generated, and the corresponding test case code is compiled and stored for the development case. The development branch and the test branch are associated. The unit test case may be based on Junit, and may also be implemented based on other test frameworks, which is exemplified below.

Each unit test case can additionally add custom comments, annotation classification level and method level 2 dimensions.

The class level mainly describes the author of the class and the purpose of setting forth the class, and the category, etc. The following:

the method level mainly expands some characteristics of the method, such as name, test scenario corresponding to the use case, author, and some additional expressions of the method (mainly used for query, statistics, etc.). The following were used:

the method has the advantages that additional attributes are defined, the purpose of the test case, what the test case is, what the result is can be specifically defined, and the attributes are mapped with the test case. The unit test case can be better managed by enhancing the test attribute of the unit.

S102, pulling a test case code and compiling the test case code into FatJar;

the GitLab pulls the development branch and the corresponding test branch. The basic component related unit test case can be maintained by a single project or an independent module in a project. When a user wants to execute a certain unit test case from the console, the related test case branch code needs to be pulled from the GitLab and then compiled into FatJar.

The traditional Junit can only be used in development environment codes, a single test case cannot be called, and a plurality of test cases in one class must be called. The unit code can be modified to support external trigger calling, so that the unit code can support automatic reflection calling and execute test cases. By changing the source code, any one use case can be independently executed through the outside.

Xml file must add FatJar packaging related configuration or else the calling of the test case may not be performed by loading FatJar, as follows:

the test cases are not put into the project, but compiled into FatJar unified management, and are triggered independently, and each test is associated with a development test, so that the test cases can be traced and managed.

Step S103, executing the test case in a FatJar reflection mode;

FatJar contains all classes. The system will load the FatJar into jvm through the custom classloader, make calls through the reflection of the class in FatJar, and execute the relevant test case.

The user can test the git address and the project branch in the control console binding unit, and the management is convenient for the future.

When a user needs to test a certain development version of a project, the user can select a test project, then obtain all branches of the project, and then obtain the test case git address of the corresponding unit according to the branches of the project.

And then, the code is pulled to the local from the git far end and then compiled into FatJar, and the FatJar is stored in a local path, so that the fact that the FatJar is compiled into the FatJar is that the versions of third party packages depending on different component versions are possibly different, if the jar package of the system is used, on one hand, a test case cannot be executed due to the version problem, and on the other hand, the jar package needing to be depended is required to be added continuously, so that the cost is increased invisibly.

And then loading the FatJar into jvm through a custom classloader, traversing all unit tests, managing and maintaining unit test information according to the association, and checking the unit test information from the front end. And the test case can be called in a reflection mode according to the test case selected from the front end, and the test case is executed.

And step S104, storing the execution result.

After the test case is executed, the execution result is stored in the database and is output to a front end (such as a user end) for query.

Managing the unit test cases according to the GitLab, and appointing that the branch of each basic component corresponds to the branch of one unit test case. And secondary development of the Junit is realized, basic attributes of the annotation rich unit test are customized, a unit test set packaged into FatJar is loaded through different classloaders by modifying source code support, so that the isolation between classes is realized, and the test case has the capability of triggering and calling from the outside, and thus, the automatic execution of the test case can be realized.

A second embodiment provides a unit testing apparatus 200, see fig. 2, comprising: a test code writing module 201, a test code management module 202, a test case management module 203 and a database 204.

A test code writing module 201 configured to write a corresponding test case code for the development case;

the test code management module 202: configured to store test case code;

A GitLab or other suitable code management tool (hereinafter, GitLab is exemplified) may be used as the test code management module 202, the unit test codes are separately stored according to branches, one branch corresponds to one version release or a large characteristic improvement, a development branch is first created, a corresponding test branch is generated, and a corresponding test case code is compiled and stored for a development case. The development branch and the test branch are associated. The unit test case may be based on Junit, and may also be implemented based on other test frameworks, which is exemplified below.

Each unit test case can additionally add custom comments, annotation classification level and method level 2 dimensions. The class level mainly describes the class author and the purpose of setting up the class, and the category, etc. The method level mainly expands some characteristics of the method, such as name, test scenario corresponding to the use case, author, and some additional expressions of the method (mainly used for query, statistics, etc.). Additional attributes are defined, the purpose of the test case is specifically defined, what is done, what is the result, and the attributes are mapped with the test case. The unit test property is enhanced, and the unit test case can be better managed.

The test case management module 203 is configured to pull the test case codes from the test code management module 202 and compile the test case codes into FatJar; executing the test case in a FatJar reflection mode;

a test case management module 203 configured to pull the test case code from the test code management module 202. The basic component related unit test case can be maintained by a single project or an independent module in a project. When a user wants to execute a certain unit test case from the console, the related test case branch code needs to be pulled from the GitLab and then compiled into FatJar.

The traditional Junit can only be used in development environment codes, a single test case cannot be called, and a plurality of test cases in one class must be called. The unit code can be modified to support external trigger calling, so that the unit code can support automatic reflection calling and execute a test case. The source code is changed, and any one use case can be independently executed through the outside.

Xml file must add FatJar packaging related configuration or else the calling of test case can not be carried out by loading FatJar.

The test case management module 203 does not put the test cases into the project, but compiles the test cases into FatJar unified management, and triggers the FatJar unified management independently, and each test is associated with a development test, can be traced and can be managed.

FatJar contains all classes. The test case management module 203 loads the FatJar into jvm through the custom classloader, calls the FatJar in a reflection mode, and executes the relevant test case.

And then loading FatJar into jvm through a custom classloader, traversing all unit tests, managing and maintaining unit test information according to the annotation, and viewing the unit test information from the front end. And the test case can be called by a reflection mode according to the test case selected from the front end, and the test case is executed.

The database 204 stores the execution result.

After the test case is executed, the execution result is stored in the database 204 and output to the front end for query.

A third embodiment also provides an electronic device including: a processor, a memory and a computer program stored in the memory for running, wherein the processor implements the steps of the method of any one of the above embodiments, such as steps S101 to S104, when executing the computer program, or implements the functions of the modules/units in each of the above embodiments, such as the functions of units 201 to 204, when executing the computer program. The computer program may be divided into one or more modules/units, which are stored in the memory and executed by the processor. The one or more modules/units may be a series of computer program instruction segments capable of performing specific functions, which are used to describe the execution process of the computer program in the electronic device.

The electronic device may be a mobile terminal such as a smart phone, or a computing device such as a desktop computer, a notebook, a palm computer, and a cloud server. The electronic device may include, but is not limited to, a processor, a memory, may include more or fewer components, or may combine certain components, e.g., the electronic device may also include an input-output device, a network access device, a bus, etc. The Processor may be a Central Processing Unit (CPU), other general purpose Processor, a Digital Signal Processor (DSP), an Application Specific Integrated Circuit (ASIC), an off-the-shelf Programmable Gate Array (FPGA) or other Programmable logic device, discrete Gate or transistor logic, discrete hardware components, etc. A general purpose processor may be a microprocessor or the processor may be any conventional processor or the like. The memory may be an internal storage unit of the electronic device, such as a hard disk or a memory of the electronic device. The memory may also be an external storage device of the electronic device, such as a plug-in hard disk, a Smart Media Card (SMC), a Secure Digital (SD) Card, a Flash memory Card (Flash Card), and the like provided on the electronic device. Further, the memory may also include both an internal storage unit and an external storage device of the electronic device.

The fifth embodiment also provides a computer-readable storage medium, which when executed by a processor implements the steps of the method of any of the above embodiments.

Each functional unit in the embodiments of the present application may be integrated into one processing unit, or each unit may exist alone physically, or two or more units are integrated into one unit. The integrated unit may be implemented in the form of hardware, or may also be implemented in the form of a software functional unit. The integrated modules/units, if implemented in the form of software functional units and sold or used as separate products, may be stored in a computer readable storage medium. Based on such understanding, all or part of the flow in the method of the embodiments described above can be realized by a computer program, which can be stored in a computer readable storage medium and can realize the steps of the embodiments of the methods described above when the computer program is executed by a processor. Wherein the computer program comprises computer program code, which may be in the form of source code, object code, an executable file or some intermediate form, etc. The computer-readable medium may include: any entity or device capable of carrying the computer program code, recording medium, usb disk, removable hard disk, magnetic disk, optical disk, computer Memory, Read-Only Memory (ROM), Random Access Memory (RAM), electrical carrier wave signals, telecommunications signals, software distribution medium, and the like. It should be noted that the computer-readable medium may contain suitable additions or subtractions depending on the requirements of legislation and patent practice in jurisdictions, for example, in some jurisdictions, computer-readable media may not include electrical carrier signals or telecommunication signals in accordance with legislation and patent practice.

It will be apparent to those skilled in the art that, for convenience and brevity of description, only the above-mentioned division of the functional units and modules is illustrated, and in practical applications, the above-mentioned function distribution may be performed by different functional units and modules according to needs, that is, the internal structure of the apparatus is divided into different functional units or modules to perform all or part of the above-mentioned functions. Each functional unit and module in the embodiments may be integrated in one processing unit, or each unit may exist alone physically, or two or more units are integrated in one unit, and the integrated unit may be implemented in a form of hardware, or in a form of software functional unit. In addition, specific names of the functional units and modules are only used for distinguishing one functional unit from another, and are not used for limiting the protection scope of the present application. The specific working processes of the units and modules in the system may refer to the corresponding processes in the foregoing method embodiments, and are not described herein again.

In the above embodiments, the descriptions of the respective embodiments have respective emphasis, and reference may be made to the related descriptions of other embodiments for parts that are not described or illustrated in a certain embodiment. Those of ordinary skill in the art will appreciate that the various illustrative elements and algorithm steps described in connection with the embodiments disclosed herein may be implemented as electronic hardware or combinations of computer software and electronic hardware. Whether such functionality is implemented as hardware or software depends upon the particular application and design constraints imposed on the implementation. Skilled artisans may implement the described functionality in varying ways for each particular application, but such implementation decisions should not be interpreted as causing a departure from the scope of the present application.

In the embodiments provided in the present application, it should be understood that the disclosed system, electronic device and method may be implemented in other ways. For example, the above-described embodiments of systems and electronic devices are merely illustrative, and for example, the division of the modules or units is only one logical division, and there may be other divisions when actually implemented, for example, a plurality of units or components may be combined or integrated into another system, or some features may be omitted, or not executed. In addition, the shown or discussed mutual coupling or direct coupling or communication connection may be an indirect coupling or communication connection through some interfaces, systems or units, and may be in an electrical, mechanical or other form. The units described as separate parts may or may not be physically separate, and parts displayed as units may or may not be physical units, may be located in one position, or may be distributed on multiple network units. Some or all of the units can be selected according to actual needs to achieve the purpose of the solution of the embodiment.

The above-mentioned embodiments are only used to illustrate the technical solutions of the present application, and not to limit the same; although the present application has been described in detail with reference to the foregoing embodiments, it should be understood by those of ordinary skill in the art that: the technical solutions described in the foregoing embodiments may still be modified, or some technical features may be equivalently replaced; such modifications and substitutions do not substantially depart from the spirit and scope of the embodiments of the present application and are intended to be included within the scope of the present application.

Claims

1. A method of unit testing, comprising:

compiling and storing corresponding test case codes for development cases;

pulling the test case code and compiling into FatJar;

executing the test case in a FatJar reflection mode;

and storing the execution result.

2. The unit testing method of claim 1, wherein the test case code further comprises annotations of at least one of: classification level annotation, method level annotation.

3. The unit testing method of claim 1, wherein the executing the test case by way of reflection by the FatJar further comprises: FatJar is loaded into jvm through the custom classloader, and the test case is executed through the reflection of the class in FatJar.

4. The unit test method of claim 1, further comprising outputting the execution results to a front end.

5. A unit testing apparatus, comprising:

the test code compiling module is configured to compile corresponding test case codes for the development cases;

the test code management module: configured to store test case code;

the test case management module is configured to pull the test case codes from the test code management module, compile the test case codes into FatJar and execute the test cases in a mode of reflection of the FatJar;

a database configured to store the execution result.

6. The unit test apparatus of claim 5, wherein the test case code further comprises annotations of at least one of: classification level annotation, method level annotation.

7. The unit testing device according to claim 5, wherein the test code management module is GitLab.

8. The unit testing device of claim 5, wherein the executing of the test case by way of reflection by FatJar comprises: FatJar is loaded into jvm through the custom classloader, and the test case is executed through the reflection of the class in FatJar.

9. An electronic device, comprising: a processor, a memory, and a computer program stored for execution on the memory, the processor, when executing the computer program, implementing the method of any of claims 1-4.

10. A computer-readable storage medium, characterized in that the computer program, when being executed by a processor, implements the method of any of claims 1-4.