CN112162931A

CN112162931A - Extraction and detection method, system, electronic equipment and storage medium

Info

Publication number: CN112162931A
Application number: CN202011185067.9A
Authority: CN
Inventors: 张玉杰
Original assignee: JD Digital Technology Holdings Co Ltd
Current assignee: JD Digital Technology Holdings Co Ltd
Priority date: 2020-10-29
Filing date: 2020-10-29
Publication date: 2021-01-01

Abstract

The embodiment of the invention relates to a method, a system, electronic equipment and a storage medium for providing test, wherein the method comprises the following steps: when the target Git branch is detected to be updated, pulling a code on the target Git branch; deploying a test environment according to the code; executing a plurality of test cases corresponding to the target Git branch in the test environment to obtain an execution result of the plurality of test cases; and generating an offering mail based on a plurality of execution results and the target Git branch and sending the offering mail. Therefore, automatic test can be realized, the execution of the self-test link is ensured, the repeated test process of the self-test link and the test-promoting link is avoided, and the efficiency of the whole code test process is improved.

Description

Extraction and detection method, system, electronic equipment and storage medium

Technical Field

The embodiment of the invention relates to the technical field of testing, in particular to a test method, a test system, electronic equipment and a storage medium.

Background

The test is to submit the code to the tester for testing after the code development is completed. At present, before the test is carried out, a developer can test the code, and after the test is passed, the test is carried out. That is, the current code testing process may include a self-testing step (i.e., a step of testing the code by a developer) and a step of testing a code (i.e., a step of testing the code by a tester), and the self-testing step and the step of testing the code are independent of each other.

However, because the current self-testing link and the current extraction link are independent from each other, repeated tests such as smoking tests are likely to exist in the self-testing link and the extraction link, which results in the fact that redundant test processes are added in the whole code test process, thereby reducing the efficiency of the code test; meanwhile, since the developer does not necessarily perform self-test on the code before the test is carried out, the test fails in the test loop, and even the probability of rejecting re-lifting is high, so that the delivery cycle of the project is affected.

Disclosure of Invention

In view of this, embodiments of the present invention provide a method and system for performing a self-test, an electronic device, and a storage medium, in order to solve the technical problems in the prior art that a redundant test process exists in a self-test link and a test loop, and the execution of the self-test link cannot be guaranteed.

In a first aspect, an embodiment of the present invention provides a method for providing a test, including:

when the target Git branch is detected to be updated, pulling a code on the target Git branch;

deploying a test environment according to the code;

executing a plurality of test cases corresponding to the target Git branch in the test environment to obtain an execution result of the plurality of test cases;

and generating an offering mail based on a plurality of execution results and the target Git branch and sending the offering mail.

In one possible embodiment, the deploying a test environment according to the code includes:

determining a target server which is matched with the configured test environment parameters and is idle from a plurality of connected test servers;

and deploying the code to the target server, and controlling the target server to run the code to complete the deployment of the test environment.

In one possible embodiment, the generating and sending a submission email based on the plurality of execution results and the target Git branch includes:

determining whether a test case with execution failure exists based on a plurality of execution results;

and if the test case with execution failure does not exist, generating a test mail based on the execution results and the target Git branch and sending the test mail.

In one possible embodiment, the method further comprises:

and if the test case with execution failure exists, outputting an indication message for indicating that the code to be tested does not pass the self-test.

In one possible embodiment, the test cases at least include smoking test cases, unit test cases and regression test cases.

In a second aspect, an embodiment of the present invention provides a test system, including: the system comprises an environment deployment module, a test module and a lifting and testing module;

the environment deployment module pulls codes on the target Git branch when detecting that the target Git branch is updated; deploying a test environment according to the code;

the test module executes a plurality of test cases corresponding to the target Git branch in the test environment to obtain the execution results of the plurality of test cases;

and the test promoting module generates a test promoting mail based on the execution results and the target Git branch and sends the test promoting mail.

In one possible embodiment of the method according to the invention,

the environment deployment module is used for determining an idle target server matched with the configured test environment parameters from a plurality of connected test servers;

In one possible embodiment of the method according to the invention,

the test extracting module is used for determining whether a test case with execution failure exists or not based on a plurality of execution results; and if the test case with execution failure does not exist, generating a test mail based on the execution results and the target Git branch and sending the test mail.

In one possible embodiment, the method further comprises:

and the output module is used for outputting an indication message for indicating that the code to be tested does not pass the self-test if the test case with execution failure exists.

In a third aspect, an embodiment of the present invention provides an electronic device, including: a processor and a memory, the processor being configured to execute a test program stored in the memory to implement the test method of any one of the first aspect.

In a fourth aspect, an embodiment of the present invention provides a storage medium, where the storage medium stores one or more programs, and the one or more programs are executable by one or more processors to implement the method for providing a test according to any one of the first aspects.

According to the technical scheme provided by the embodiment of the invention, when the target Git branch is detected to be updated, the codes on the target Git branch are pulled, the test environment is deployed according to the codes, a plurality of test cases corresponding to the target Git branch are executed in the test environment, the execution results of the plurality of test cases are obtained, the extracting and testing mail is generated and sent based on the plurality of execution results and the target Git branch, and the automatic extracting and testing are realized when the target Git branch is updated.

Meanwhile, the code is automatically tested before being upgraded, so that the execution of a self-testing link is ensured, and the probability that the test fails to pass or even the repeated upgrade is rejected in the upgrading link can be reduced. Because the test mail is generated based on the execution results of the plurality of test cases, the tester can know which test processes are performed in the self-test link, so that the tester can be prevented from repeatedly executing some test processes in the test process, and the efficiency of the whole code test process is improved.

Drawings

Fig. 1 is a flowchart of an embodiment of a method for performing an analysis according to an embodiment of the present invention;

FIG. 2 is a block diagram of an embodiment of a test system according to the present invention;

fig. 3 is a schematic structural diagram of an electronic device according to an embodiment of the present invention.

Detailed Description

In order to make the objects, technical solutions and advantages of the embodiments of the present invention clearer, the technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the drawings in the embodiments of the present invention, and it is obvious that the described embodiments are some, but not all, embodiments of the present invention. All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present invention.

The method provided by the present invention is further explained with specific embodiments in the following with reference to the drawings, and the embodiments do not limit the embodiments of the present invention.

Referring to fig. 1, a flowchart of an embodiment of a method for performing an analysis according to an embodiment of the present invention is shown. As an embodiment, the method may be applied to a test system, and optionally, the test system may be deployed on a single electronic device or a device cluster, and the test system is described below by using the embodiment shown in fig. 2, which will not be described in detail here.

As shown in fig. 1, the method comprises the following steps:

and step 101, pulling the code on the target Git branch when the target Git branch is detected to be updated.

Git is an open-source, distributed version control system that can handle project version management from very small to very large versions efficiently and at high speed, and in practice, more and more developers use Git to manage project development. The Git branch is used for separating tasks, such as testing, new function development, vulnerability repair and the like, from a project development main line so as to avoid influencing the project development main line, thereby ensuring the stability and the safety of the project development process.

Based on this, as one embodiment, the automatic test flow of code may be triggered by monitoring the Git branch. Specifically, the Git address and the Git branch (hereinafter referred to as the target Git branch) to be monitored may be preset by a developer, so that when an update of the target Git branch is detected, an automatic test flow may be triggered.

In this step 101, when it is detected that the target Git branch is updated, the code on the target Git branch is pulled from the Git repository, so that the subsequent extraction flow of the pulled code is developed. It will be appreciated that the code pulled is the newly developed code.

And step 102, deploying a test environment according to the codes.

The test environment comprises a hardware environment and a software environment, wherein the hardware environment refers to an environment formed by auxiliary hardware equipment such as a server, a client, network connection equipment, a printer/scanner and the like which are necessary for testing; the software environment refers to an environment formed by an operating system, a database and other application software when the tested software/code runs. Further, under normal circumstances, the test environments required by different items and different functions are likely to be different, for example, one tested software needs to occupy a larger memory space when running, and another tested software only needs to occupy a smaller memory space when running, so in practice, the test environment corresponding to the previous tested software may be required to have a larger memory space.

Based on this, as an embodiment, a developer may configure test environment parameters in advance according to actual requirements, when the test environment is deployed by the test system, determine a server (hereinafter referred to as a target server) that is idle and matches the configured test environment parameters from a plurality of connected test servers, deploy the code obtained in the step 101 to the target server, and control the target server to run the code, thereby completing the deployment of the test environment.

Optionally, the test environment parameters include hardware environment parameters and software environment parameters, where the hardware environment parameters include but are not limited to: CPU core number, memory capacity, disk capacity, etc.; software environment parameters include, but are not limited to: jdk version, tomcat version, etc.

Optionally, the test system may deploy the code obtained in step 101 to the target server based on a jenkins pipeline workflow framework, and send a command to the target server based on the jenkins pipeline workflow framework to control the target server to run the code, thereby completing the deployment of the test environment.

As one embodiment, the proposed test system can manage a plurality of test servers, store hardware parameters and software parameters of the plurality of test servers, and monitor the status (including idle and non-idle) of each test server. Thus, the proposed test system can determine a free target server matching the configured test environment parameters from the connected multiple test servers in step 102.

And 103, executing a plurality of test cases corresponding to the target Git branch in the test environment to obtain an execution result of the plurality of test cases.

And 104, generating a test mail based on the plurality of execution results and the target Git branch and sending the test mail.

Step 103 and step 104 are explained below collectively:

as can be seen from the

above steps

103 and 104, in the embodiment of the present invention, before the loop is extracted, the code to be tested (i.e., the code pulled in step 101) is automatically tested, which can ensure that the code to be tested is self-tested before the loop is extracted, so that the probability that the test fails or even the loop is rejected in the extraction loop can be reduced.

Specifically, the above-mentioned test system can support the mainstream automated test framework at present, including but not limited to: based on the fact that the test system can trigger the test based on the automated test framework in step 103, in the test process, the test system can execute a plurality of test cases corresponding to the target Git branch in the test environment by interacting with the test server, so as to obtain the execution results of the plurality of test cases. In practice, the plurality of test cases may be set by a developer and a tester together before testing. Optionally, the test case includes but is not limited to: unit test cases, smoke test cases, regression test cases, and the like.

As an embodiment, in an application, in order to effectively reduce the probability of failing to test or even rejecting re-extraction in a test extraction link, in step 104, it is first determined whether there is a test case with failed execution based on the execution results of multiple test cases, and if there is no test case with failed execution, it means that the code under test can run correctly and stably, so that a subsequent test extraction link can be performed.

In step 104, a test mail is generated and sent based on the execution results of the plurality of test cases and the target Git branch, as one embodiment. Specifically, the extracting and testing system can extract information such as the target Git branch and the change range of the target Git branch and fill the information in a preset extracting and testing template, generate a testing report based on the execution results of a plurality of testing cases, and generate an extracting and testing mail by using the extracting and testing template and the testing report and send the extracting and testing mail to corresponding testing personnel. Therefore, the test mail generated by the embodiment of the invention not only comprises the content to be tested, but also comprises the test report of the self-test link, so that the tester can know which test processes are performed in the self-test link based on the test report, and the tester can be prevented from repeatedly executing some test processes in the test process, thereby improving the efficiency of the whole code test process.

Optionally, the test report includes, but is not limited to, a type, an execution result, and the like of each test case.

In addition, if it is determined in step 104 that there is a test case with execution failure, it means that the code under test cannot run correctly and stably, and at this time, an indication message indicating that the code under test fails self-test may be output, so that the developer modifies the code under test. It can be understood that through the processing, the code which cannot run correctly can be effectively prevented from being submitted to a tester, so that unnecessary work is brought to the tester, and the project development cycle is prolonged.

Referring to fig. 2, a block diagram of an embodiment of a test system according to an embodiment of the present invention is provided. As shown in fig. 2, the presentation system includes: an environment deployment module 21, a test module 22, and a provision module 23;

the environment deployment module 21, when detecting that a target Git branch is updated, pulls a code on the target Git branch; deploying a test environment according to the code;

the test module 22 executes a plurality of test cases corresponding to the target Git branch in the test environment to obtain an execution result of the plurality of test cases;

and the submission module 23 is configured to generate a submission email based on the plurality of execution results and the target Git branch, and send the submission email.

In one possible embodiment of the method according to the invention,

the environment deployment module 21 determines an idle target server matched with the configured test environment parameters from the connected plurality of test servers;

In one possible embodiment of the method according to the invention,

the test-promoting module 23 determines whether there is a test case with execution failure based on the plurality of execution results; and if the test case with execution failure does not exist, generating a test mail based on the execution results and the target Git branch and sending the test mail.

In a possible embodiment, it also comprises (not shown in fig. 2):

Fig. 3 is a schematic structural diagram of an electronic device according to an embodiment of the present invention, where the electronic device 300 shown in fig. 3 includes: at least one processor 301, memory 302, at least one network interface 304, and other user interfaces 303. The various components in electronic device 300 are coupled together by a bus system 305. It will be appreciated that the bus system 305 is used to enable communications among the components connected. The bus system 305 includes a power bus, a control bus, and a status signal bus in addition to a data bus. For clarity of illustration, however, the various buses are labeled as bus system 305 in fig. 3.

The user interface 303 may include, among other things, a display, a keyboard, or a pointing device (e.g., a mouse, trackball, touch pad, or touch screen, among others.

It will be appreciated that the memory 302 in embodiments of the invention may be either volatile memory or nonvolatile memory, or may include both volatile and nonvolatile memory. The non-volatile memory may be a Read-only memory (ROM), a programmable Read-only memory (PROM), an erasable programmable Read-only memory (erasabprom, EPROM), an electrically erasable programmable Read-only memory (EEPROM), or a flash memory. The volatile memory may be a Random Access Memory (RAM) which functions as an external cache. By way of example, but not limitation, many forms of RAM are available, such as static random access memory (staticiram, SRAM), dynamic random access memory (dynamic RAM, DRAM), synchronous dynamic random access memory (syncronous DRAM, SDRAM), double data rate synchronous dynamic random access memory (DDRSDRAM ), Enhanced Synchronous DRAM (ESDRAM), Synchronous Link DRAM (SLDRAM), and direct memory bus RAM (DRRAM). The memory 302 described herein is intended to comprise, without being limited to, these and any other suitable types of memory.

In some embodiments, memory 302 stores the following elements, executable units or data structures, or a subset thereof, or an expanded set thereof: an operating system 3021 and application programs 3022.

The operating system 3021 includes various system programs, such as a framework layer, a core library layer, a driver layer, and the like, and is used for implementing various basic services and processing hardware-based tasks. The application programs 3022 include various application programs such as a media player (MediaPlayer), a Browser (Browser), and the like, for implementing various application services. A program implementing the method of an embodiment of the present invention may be included in the application program 3022.

In the embodiment of the present invention, by calling a program or an instruction stored in the memory 302, specifically, a program or an instruction stored in the application 3022, the processor 301 is configured to execute the method steps provided by the method embodiments, for example, including:

deploying a test environment according to the code;

In one possible embodiment, the method further comprises:

The method disclosed in the above embodiments of the present invention may be applied to the processor 301, or implemented by the processor 301. The processor 301 may be an integrated circuit chip having signal processing capabilities. In implementation, the steps of the above method may be performed by integrated logic circuits of hardware or instructions in the form of software in the processor 301. The processor 301 may be a 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 device, or discrete hardware component. The various methods, steps and logic blocks disclosed in the embodiments of the present invention may be implemented or performed. A general purpose processor may be a microprocessor or the processor may be any conventional processor or the like. The steps of the method disclosed in connection with the embodiments of the present invention may be directly implemented by a hardware decoding processor, or implemented by a combination of hardware and software elements in the decoding processor. The software elements may be located in ram, flash, rom, prom, or eprom, registers, among other storage media that are well known in the art. The storage medium is located in the memory 302, and the processor 301 reads the information in the memory 302 and completes the steps of the method in combination with the hardware.

It is to be understood that the embodiments described herein may be implemented in hardware, software, firmware, middleware, microcode, or any combination thereof. For a hardware implementation, the processing units may be implemented within one or more Application Specific Integrated Circuits (ASICs), Digital Signal Processors (DSPs), Digital Signal Processing Devices (DSPDs), Programmable Logic Devices (PLDs), Field Programmable Gate Arrays (FPGAs), general purpose processors, controllers, micro-controllers, microprocessors, other electronic units configured to perform the functions described herein, or a combination thereof.

For a software implementation, the techniques described herein may be implemented by means of units performing the functions described herein. The software codes may be stored in a memory and executed by a processor. The memory may be implemented within the processor or external to the processor.

The electronic device provided in this embodiment may be the electronic device shown in fig. 3, and may perform all the steps of the method for testing shown in fig. 1, so as to achieve the technical effect of the method for testing shown in fig. 1.

The embodiment of the invention also provides a storage medium (computer readable storage medium). The storage medium herein stores one or more programs. Among others, the storage medium may include volatile memory, such as random access memory; the memory may also include non-volatile memory, such as read-only memory, flash memory, a hard disk, or a solid state disk; the memory may also comprise a combination of memories of the kind described above.

When one or more programs in the storage medium are executable by one or more processors, the method for providing the test performed on the electronic device side is implemented.

The processor is used for executing the extracting program stored in the memory so as to realize the following steps of the extracting method executed on the electronic equipment side:

deploying a test environment according to the code;

In one possible embodiment, the method further comprises:

Those of skill would further appreciate that the various illustrative components and algorithm steps described in connection with the embodiments disclosed herein may be implemented as electronic hardware, computer software, or combinations of both, and that the various illustrative components and steps have been described above generally in terms of their functionality in order to clearly illustrate this interchangeability of hardware and software. 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 invention.

The steps of a method or algorithm described in connection with the embodiments disclosed herein may be embodied in hardware, a software module executed by a processor, or a combination of the two. A software module may reside in Random Access Memory (RAM), memory, Read Only Memory (ROM), electrically programmable ROM, electrically erasable programmable ROM, registers, hard disk, a removable disk, a CD-ROM, or any other form of storage medium known in the art.

The above-mentioned embodiments are intended to illustrate the objects, technical solutions and advantages of the present invention in further detail, and it should be understood that the above-mentioned embodiments are merely exemplary embodiments of the present invention, and are not intended to limit the scope of the present invention, and any modifications, equivalent substitutions, improvements and the like made within the spirit and principle of the present invention should be included in the scope of the present invention.

Claims

1. A method of performing an assay, comprising:

deploying a test environment according to the code;

2. The method of claim 1, wherein deploying the test environment according to the code comprises:

3. The method of claim 1, wherein generating and sending an email based on the plurality of execution results and the target Git branch comprises:

4. The method of claim 3, further comprising:

5. The method according to any one of claims 1 to 4, wherein the test cases at least include smoking test cases, unit test cases, and regression test cases.

6. An extraction system, comprising: the system comprises an environment deployment module, a test module and a lifting and testing module;

7. The system of claim 6,

8. The system of claim 6,

9. An electronic device, comprising: a processor and a memory, the processor being configured to execute a test program stored in the memory to implement the test method of any one of claims 1 to 5.

10. A storage medium storing one or more programs executable by one or more processors to implement the method of any one of claims 1 to 5.