CN115168212A - Method, device, equipment and computer readable medium for testing software - Google Patents

Abstract

The invention discloses a method, a device, equipment and a computer readable medium for testing software, and relates to the technical field of computers. One embodiment of the method comprises: responding to a successful code submitting message of a client in the distributed version control system, calling a controller to receive test software through a network application programming interface, wherein the test software comprises a client production resource file and a source code resource file; according to the production resource codes of the source code resource file, a server production resource file is constructed; determining that the client production resource file is consistent with the server production resource file, and the code snapshot of the source code resource file is consistent with the code snapshot of the historical source code resource file; and loading the test software by adopting a browser, and feeding back a test result of the test software based on the display content of the browser. The implementation mode can avoid the process of testing the software by human intervention and improve the software testing efficiency.

Description

Method, apparatus, apparatus and computer readable medium for testing software

technical field

The present invention relates to the field of computer technology, and in particular, to a method, apparatus, device and computer-readable medium for testing software.

Background technique

With the continuous development of front-end development technology and the continuous popularization of HTML5 technology, the demand for web pages on the browser side is also increasing. While rapid iterative development meets the needs of web pages, it is inseparable from each resource server deployment, implementation of online and testing.

During the process of implementing the present invention, the inventor found that there are at least the following problems in the prior art: human intervention in the software testing process results in low software testing efficiency.

SUMMARY OF THE INVENTION

In view of this, embodiments of the present invention provide a method, apparatus, device, and computer-readable medium for testing software, which can avoid human intervention in the software testing process and improve software testing efficiency.

To achieve the above object, according to an aspect of the embodiments of the present invention, a method for testing software is provided, including:

In response to the successful message of the client submitting the code in the distributed version control system, the controller is invoked to receive the test software through the network application programming interface, and the test software includes the client production resource file and the source code resource file;

Build a server-side production resource file according to the production resource code of the source code resource file;

It is determined that the client production resource file is consistent with the server production resource file, and the code snapshot of the source code resource file is consistent with the code snapshot of the historical source code resource file;

A browser is used to load the test software, and based on the displayed content of the browser, the test results of the test software are fed back.

Before the response to the client in the distributed version control system submitting the code success message, the method further includes:

The test software is associated with the distributed version control system, which receives the test software.

The construction of the server-side production resource file according to the production resource code of the source code resource file includes:

According to the production resource code of the source code resource file, the production resource file corresponding to the production resource code is installed to construct the server production resource file.

The code snapshot of the source code resource file is consistent with the code snapshot of the historical source code resource file in the server, including:

Based on the version identifier of the source code resource file, the historical code resource file specified in the server;

Using a browsing simulator, the source code resource file and the designated historical source code resource file are respectively combined to obtain a code snapshot of the source code resource file and a code snapshot of the historical source code resource file;

It is determined that the code snapshot of the source code resource file is consistent with the code snapshot of the historical source code resource file in the server.

The designated historical code resource file includes a historical code resource file closest to the version identifier.

The browser is used to load the test software, and based on the displayed content of the browser, the test results of the test software are fed back, including:

A browser is used to execute the test software, and based on the browser to render the displayed content of the page, the test result of the test software is fed back, and the rendered page is a designated page in the source code resource file.

The browser is used to load the test software, and based on the displayed content of the browser, the test results of the test software are fed back, including:

Use a browser to load the test software, and render and display the content based on the browser failure;

The loading request of the browser is redirected to the backup server, the test software is loaded again in the backup server, and the test result of the test software is fed back.

According to a second aspect of the embodiments of the present invention, an apparatus for testing software is provided, including:

The receiving module is used for invoking the controller to receive the test software through the network application programming interface in response to the client submitting the code success message in the distributed version control system, and the test software includes the client production resource file and the source code resource file;

a building module for constructing a server-side production resource file according to the production resource code of the source code resource file;

a determining module, configured to determine that the client production resource file is consistent with the server production resource file, and the code snapshot of the source code resource file is consistent with the code snapshot of the historical source code resource file;

The feedback module is used to load the test software by using a browser, and feed back the test results of the test software based on the displayed content of the browser.

According to a third aspect of the embodiments of the present invention, an electronic device for testing software is provided, including:

one or more processors;

storage means for storing one or more programs,

The one or more programs, when executed by the one or more processors, cause the one or more processors to implement the method as described above.

According to a fourth aspect of the embodiments of the present invention, there is provided a computer-readable medium on which a computer program is stored, and when the program is executed by a processor, the above-mentioned method is implemented.

An embodiment of the above invention has the following advantages or beneficial effects: in response to the client in the distributed version control system submitting the code success message, the controller is invoked to receive the test software through the network application programming interface, and the test software includes the client production resource file and source code resource file; build a server production resource file according to the production resource code of the source code resource file; determine that the client production resource file is consistent with the server production resource file, and the source The code snapshot of the code resource file is consistent with the code snapshot of the historical source code resource file; the test software is loaded by a browser, and the test result of the test software is fed back based on the display content of the browser. By comparing the production resource files, it is judged that the production environment is the same, and the code snapshots are compared to ensure that the existing code is consistent, and then the test software is loaded in the browser to feedback the test results. The above process is performed automatically without manual intervention, thereby improving the efficiency of software testing.

Further effects of the above non-conventional alternatives will be described below in conjunction with specific embodiments.

Description of drawings

The accompanying drawings are used for better understanding of the present invention and do not constitute an improper limitation of the present invention. in:

Fig. 1 is the main flow schematic diagram of the method for testing software according to an embodiment of the present invention;

2 is a schematic flowchart of a code snapshot of a comparison source code resource file according to an embodiment of the present invention;

3 is a schematic flowchart of a browser-based display content feedback test result of the test software according to an embodiment of the present invention;

4 is a schematic flowchart of a method for executing test software according to an embodiment of the present invention;

5 is a schematic diagram of the main structure of an apparatus for testing software according to an embodiment of the present invention;

FIG. 6 is an exemplary system architecture diagram to which an embodiment of the present invention may be applied;

FIG. 7 is a schematic structural diagram of a computer system suitable for implementing a terminal device or a server according to an embodiment of the present invention.

Detailed ways

Exemplary embodiments of the present invention are described below with reference to the accompanying drawings, which include various details of the embodiments of the present invention to facilitate understanding and should be considered as exemplary only. Accordingly, those of ordinary skill in the art will recognize that various changes and modifications of the embodiments described herein can be made without departing from the scope and spirit of the invention. Also, descriptions of well-known functions and constructions are omitted from the following description for clarity and conciseness.

Existing software deployment solutions include: writing business logic as html code, manually building and packaging locally, uploading to the staging environment, deploying on the back-end server, and testing for function points. According to the above deployment scheme, there are the following disadvantages:

Disadvantage 1. Each deployment needs to upload the dist deployment package. Each developer's dependency environment is different, and the constructed resource package may also be different.

Disadvantage 2. Frequent input of manpower to test function points, and it is impossible to fully test all pages. Partial modification of the code may cause errors in other dependent modules.

To sum up, the efficiency of software testing is low due to human intervention in the testing software process.

In order to solve the problem of low software testing efficiency, the following technical solutions in the embodiments of the present invention may be adopted.

Referring to FIG. 1, FIG. 1 is a schematic diagram of the main flow of a method for testing software according to an embodiment of the present invention. It is judged that the production environment is the same by comparing the production resource files, and the code snapshots are compared to ensure that the existing codes are consistent, and then the browser is used to load the test software, to provide feedback on test results. As shown in Figure 1, it specifically includes the following steps:

S101. In response to the successful message of the client submitting the code in the distributed version control system, call the controller to receive the test software through the network application programming interface, where the test software includes the client production resource file and the source code resource file.

In this embodiment of the present invention, the software developer can upload the test software through the client. Specifically, in the client, the user creates an html project, and then generates test software for the html project.

As an example, use front-end domain tools such as VueCli to create an html project. For example: enter the project name, VueCli automatically generates file resources such as js and vue folders, and automatically installs the dependent packages required by the project. Write business logic normally, build production environment code, and generate dist file resource bundle. Among them, the dist file resource package is the client production resource file.

On the client side, use a distributed version control system (git) init script to associate with git. For example: generate .git hidden folders and other related configurations in the project root directory. Using the above configuration, the git init script is associated with git. to upload the test software to git. That is, associate the test software with git, and git receives the test software.

Compared with the client, the server is used to test the software. It can be understood that the server is the execution body of each step of the test software. Specifically, the server creates a backend service. As an example, the server uses node.js to create a backend service. node.js is a JavaScript runtime environment based on the Chrome V8 engine, using an event-driven, non-blocking I/O model.

Listen to the client through the git repository service webhook. In this way, after monitoring that the client has uploaded the test software, the controller WebHooksController can be called to receive the test software through the web application programming interface (WebAPI) in response to the successful message of the client submitting the code in git. Among them, WebAPI is sent by git webhook.

In the embodiment of the present invention, the test software specifically includes a client-side production resource file and a source code resource file. The client-side production resource file represents the production environment of the test software. Source code resource files are used to generate html pages. As an example, the test software is noted as release v1.0. It will be appreciated that the test software is marked with a version identifier. Such as: v1.0, v2.0. The higher the number of the version ID, the newer the version.

S102 , constructing a server-side production resource file according to the production resource code of the source code resource file.

After the server receives the test software, in order to judge the production environment of the test software, a production resource file needs to be constructed on the server.

Specifically, the controller receives information through WebAPI, and analyzes whether it is "release vXX" information. The test software is usually identified by release vXX. After it is determined that the test software is received, the server builds the server production resource file according to the production resource code of the source code resource file.

In one embodiment of the present invention, production resource code is included in the source code resource file. The production resource code is used to identify the version of the production resource file. Install the production resource file corresponding to the production resource code on the server to realize the construction of the server production resource file. That is, according to the production resource code of the source code resource file, install the production resource file corresponding to the production resource code to construct the server production resource file.

As an example, based on the production resource code on the server side, install dependencies on the server side to build and generate the server dist resource package. Among them, the server dist resource package is the server production resource file.

S103. Determine that the client production resource file is consistent with the server production resource file, and the code snapshot of the source code resource file is consistent with the code snapshot of the historical source code resource file.

In the embodiment of the present invention, in order to improve the accuracy of the testing software, it is necessary to compare the production resource file and the source code resource file respectively.

The purpose of comparing the production resource files is to ensure the accuracy of the production environment of the test software. In the process of practical application of test software, it is easy to cause the test software to fail due to differences in the production environment. Specifically, the production environment of Vc5.0 is used on the client side; the production environment of Vc6.0 is used on the server side. Because the production environment is different, it is necessary to cause the test software to fail.

Therefore, in the embodiment of the present invention, the production environment is compared by comparing the production resource files. When the production environment is consistent, compare the code snapshots.

In the embodiment of the present invention, if it is determined that the client production resource file is inconsistent with the server production resource file, it means that the production environment of the client is different from the server production environment, and the test software fails; If the resource files are consistent, it means that the production environment of the client is the same as the production environment of the server, then continue to compare the code snapshots.

Referring to FIG. 2, FIG. 2 is a schematic flowchart of comparing code snapshots of source code resource files according to an embodiment of the present invention. Specifically include the following steps:

The purpose of comparing the code snapshots of the source code resource files is to ensure the accuracy of the historical code in the test software.

S201 , specifying a historical code resource file in the server based on the version identifier of the source code resource file.

In the embodiment of the present invention, the source code resource file is marked with a version identifier. As an example, the version identifier of the source code resource file is V1.1, the version identifier of the source code resource file is V1.2, and so on. The larger the number identified by the version label, the newer the corresponding version. Such as: the version of V1.2 is the updated version of V1.1.

During each software testing process, the server needs to store the testing software. Understandably, the server stores multiple versions of the test software. As an example, the server stores the test software of three versions of the test software V1.0, V1.1 and V1.2.

Compared with the version of the existing source code resource file, the purpose of the current test software is to test whether the new code of the current version is running normally, and the code snapshot method is used to test the historical code of the current version and the original version.

Therefore, based on the version identifier of the source code resource file, the historical code resource file is specified in the server, so that the code snapshot method is used to test the same code in the source code resource file as the specified historical code resource file. In this way, the code snapshot of the source code resource file is compared with the code snapshot of the specified historical source code resource.

In one embodiment of the present invention, the designated historical code resource file includes a historical code resource file closest to the version identifier. The historical code resource file with the latest version identification has the smallest difference from the source code resource file, and the number of codes in the code snapshot is increased to improve the test efficiency.

S202 , a browsing simulator is used to obtain a code snapshot of the source code resource file and a code snapshot of the historical source code resource file in combination with the source code resource file and the specified historical source code resource file respectively.

For source code resource files, a browsing simulator is used to obtain a code snapshot of the source code resource file; and for a specified historical source code resource file, a browsing simulator is used to obtain a code snapshot of the historical source code resource file.

Code snapshots include the contents of source code resource files. As one example, the content of a source code resource file includes code to execute software.

As an example, a browsing emulator includes Puppeteer. puppeteer is a Node.js package that emulates the running of the Chrome browser. On the server side, the Puppeteer browsing emulator is configured by default.

S203. Determine that the code snapshot of the source code resource file is consistent with the code snapshot of the historical source code resource file in the server.

If it is determined that the code snapshot of the source code resource file is consistent with the code snapshot of the historical source code resource file in the server, it means that the source code resource file has the same code as the specified historical code resource file and passed the test. As an example, Puppeteer is used to determine that the code snapshot of the source code resource file is consistent with the code snapshot of the historical source code resource file in the server.

It should be noted that, in the following cases, it can be directly determined that the test software fails. Make sure that the client-side production resource file is different from the server-side production resource file. And, it is determined that the client-side production resource file is consistent with the server-side production resource file, and the code snapshot of the source code resource file is different from the code snapshot of the historical source code resource file.

In the embodiment of FIG. 2, a browsing simulator is used to implement code snapshot comparison of source code resource files, and to test the same code in the source code resource file with the specified historical code resource file.

S104, the browser is used to load the test software, and based on the displayed content of the browser, the test result of the test software is fed back.

In the embodiment of the present invention, the testing software is used to display an html page. Therefore, a browser can be used to load the test software, and based on the displayed content of the browser, the test results of the test software can be fed back.

In the embodiment of the present invention, for a specified page, a browser is used to display the display content of the specified service to determine the test software. Specifically, the browser is used to execute the test software, and the display content of the page is rendered based on the browser, and the test result of the test software is fed back, and the rendered page is a designated page in the source code resource file.

As an example, if the display content in the rendered page is consistent with the display content in the specified page, the test result of the feedback test software is passed the test; correspondingly, the display content in the rendered page is different from the display content in the specified page. Then the test result of the feedback test software is a failed test. Different from the display content in the specified page, including: display error 404.

It can be understood that by displaying the specified page, the test result can be directly determined.

Referring to FIG. 3, FIG. 3 is a schematic flowchart of a browser-based display content feedback testing software test result according to an embodiment of the present invention. Specifically include the following steps:

S301 , using a browser to load the test software, and rendering and displaying the content based on the browser fails.

The test software is loaded by the browser, and the display content fails based on the browser rendering. Browser rendering of displayed content can fail for a variety of reasons: a production server failure or a bug in the test software, etc.

In order to avoid the failure of the test software caused by the server failure, you can also test the software through the backup server.

S302: Redirect the loading request of the browser to the backup server, and reload the test software in the backup server to feed back the test result of the test software.

A backup server is set in advance, and the backup server can be understood as a disaster recovery server. The browser's loading request is redirected to the backup server, and the test software is reloaded in the backup server, and the test results of the test software are fed back. Through the backup server, if the display content of the page in the test software can be displayed normally, the test result of the test software is passed the test; correspondingly, if the display content of the page in the test software cannot be displayed normally through the backup server, the test result of the test software is Failed the test.

As an example, a URL for the production server represents the production environment, and URL b for the backup server represents the disaster recovery environment.

Using a browser to access a website, that is, directing the browser's loading request to the production server, loading the test software, and rendering the content based on the browser fails. Redirect the loading request of the browser to the backup server, load the test software again through the b URL, and feed back the test results of the test software.

In the above-mentioned embodiment of the present invention, in response to the successful message of the code submitted by the client in the distributed version control system, the controller is invoked to receive the test software through the network application programming interface, and the test software includes the client production resource file and the source code. code resource file; build a server-side production resource file according to the production resource code of the source code resource file; determine that the client-side production resource file is consistent with the server-side production resource file, and the code of the source code resource file The snapshot is consistent with the code snapshot of the historical source code resource file; a browser is used to load the test software, and based on the displayed content of the browser, the test results of the test software are fed back. By comparing the production resource files, it is judged that the production environment is the same, and the code snapshots are compared to ensure that the existing code is consistent, and then the test software is loaded in the browser to feedback the test results. The above process is performed automatically without manual intervention, thereby improving the efficiency of software testing.

Referring to FIG. 4, FIG. 4 is a schematic flowchart of a method for executing test software according to an embodiment of the present invention. Specifically include the following steps:

S401. The developer creates test software on the client.

Software developers can upload test software through the client. Specifically, in the client, the user creates an html project, and then generates test software for the html project.

S402, upload the test software to the distributed version control system.

On the client side, the test software is associated with git, and git receives the uploaded test software.

S403, the monitoring client has uploaded the test software.

Use webhook to monitor the client. In this way, after monitoring that the client has uploaded the test software, you can respond to the successful message of the client submitting the code in git,

S404 , constructing a server-side production resource file.

After the server receives the test software, in order to judge the production environment of the test software, a production resource file needs to be constructed on the server.

S405, it is determined that the client production resource file is consistent with the server production resource file.

If it is determined that the client production resource file is the same as the server production resource file, it means that the production environment of the client and the server is the same. If it is determined that the client-side production resource file is different from the server-side production resource file, the test software fails.

S406. Determine that the code snapshot of the source code resource file is consistent with the code snapshot of the historical source code resource file.

Confirm that the code snapshot of the source code resource file is consistent with the code snapshot of the historical source code resource file, and continue to use the browser to test the software; if it is determined that the code snapshot of the source code resource file is different from the code snapshot of the historical source code resource file, the test software fails.

S407, the display content of the test software is successfully rendered by the production server.

If the display content of the test software is successfully rendered by the production server, the test result is a passing test. If rendering the display content of the test software through the production server fails, the browser's loading request is redirected to the backup server.

S408, the display content of the test software is successfully rendered through the backup server.

If the display content of the test software is successfully rendered through the backup server, the test result is a pass test. If the display content of the test software is failed to be rendered by the backup server, the test result is a failed test.

Referring to FIG. 5, FIG. 5 is a schematic diagram of the main structure of a device for testing software according to an embodiment of the present invention. The device for testing software can implement a method for testing software. As shown in FIG. 5, the device for testing software specifically includes:

The receiving module 501 is used for in response to the client in the distributed version control system submitting the code success message, calling the controller to receive the test software through the network application programming interface, and the test software includes the client production resource file and the source code resource file ;

A construction module 502, configured to construct a server-side production resource file according to the production resource code of the source code resource file;

A determination module 503, configured to determine that the client production resource file is consistent with the server production resource file, and the code snapshot of the source code resource file is consistent with the code snapshot of the historical source code resource file;

The feedback module 504 is configured to load the test software by using a browser, and feed back the test result of the test software based on the displayed content of the browser.

In an embodiment of the present invention, the receiving module 501 is specifically configured to associate the test software with the distributed version control system, and the distributed version control system receives the test software.

In an embodiment of the present invention, the building module 502 is specifically configured to install the production resource file corresponding to the production resource code according to the production resource code of the source code resource file, so as to construct the server production resource file.

In an embodiment of the present invention, the determining module 503 is specifically configured to specify the historical code resource file in the server based on the version identifier of the source code resource file;

Using a browsing simulator, the source code resource file and the designated historical source code resource file are respectively combined to obtain a code snapshot of the source code resource file and a code snapshot of the historical source code resource file;

It is determined that the code snapshot of the source code resource file is consistent with the code snapshot of the historical source code resource file in the server.

In an embodiment of the present invention, the specified historical code resource file includes a historical code resource file closest to the version identifier.

In an embodiment of the present invention, the feedback module 504 is specifically configured to use a browser to execute the test software, and based on the browser to render the display content of the page, feedback the test result of the test software, and the rendered page is the specified page in the source code resource file.

In an embodiment of the present invention, the feedback module 504 is specifically configured to use a browser to load the test software, and render and display the content failure based on the browser;

The loading request of the browser is redirected to the backup server, the test software is loaded again in the backup server, and the test result of the test software is fed back.

FIG. 6 shows an exemplary system architecture 600 of a method for testing software or an apparatus for testing software to which embodiments of the present invention may be applied.

As shown in FIG. 6 , the system architecture 600 may include terminal devices 601 , 602 , and 603 , a network 604 and a server 605 . The network 604 is a medium used to provide a communication link between the terminal devices 601 , 602 , 603 and the server 605 . Network 604 may include various connection types, such as wired, wireless communication links, or fiber optic cables, among others.

The user can use the terminal devices 601, 602, 603 to interact with the server 605 through the network 604 to receive or send messages and the like. Various communication client applications may be installed on the terminal devices 601 , 602 and 603 , such as shopping applications, web browser applications, search applications, instant messaging tools, email clients, social platform software, etc. (just examples).

The terminal devices 601, 602, 603 may be various electronic devices having a display screen and supporting web browsing, including but not limited to smart phones, tablet computers, laptop computers, desktop computers, and the like.

The server 605 may be a server that provides various services, such as a background management server that supports shopping websites browsed by the terminal devices 601 , 602 , and 603 (just an example). The background management server can analyze and process the received product information query request and other data, and feed back the processing results (such as target push information, product information—just an example) to the terminal device.

It should be noted that the method for testing software provided in the embodiment of the present invention is generally executed by the server 605 , and accordingly, the apparatus for testing the software is generally set in the server 605 .

It should be understood that the numbers of terminal devices, networks and servers in FIG. 6 are merely illustrative. There can be any number of terminal devices, networks and servers according to implementation needs.

Referring next to FIG. 7 , it shows a schematic structural diagram of a computer system 700 suitable for implementing a terminal device according to an embodiment of the present invention. The terminal device shown in FIG. 7 is only an example, and should not impose any limitations on the functions and scope of use of the embodiments of the present invention.

As shown in FIG. 7, a computer system 700 includes a central processing unit (CPU) 701, which can be loaded into a random access memory (RAM) 703 according to a program stored in a read only memory (ROM) 702 or a program from a storage section 708 Instead, various appropriate actions and processes are performed. In the RAM 703, various programs and data necessary for the operation of the system 700 are also stored. The CPU 701 , the ROM 702 , and the RAM 703 are connected to each other through a bus 704 . An input/output (I/O) interface 705 is also connected to bus 704 .

The following components are connected to the I/O interface 705: an input section 706 including a keyboard, a mouse, etc.; an output section 707 including a cathode ray tube (CRT), a liquid crystal display (LCD), etc., and a speaker, etc.; a storage section 708 including a hard disk, etc. ; and a communication section 709 including a network interface card such as a LAN card, a modem, and the like. The communication section 709 performs communication processing via a network such as the Internet. A drive 710 is also connected to the I/O interface 705 as needed. A removable medium 711, such as a magnetic disk, an optical disk, a magneto-optical disk, a semiconductor memory, etc., is mounted on the drive 710 as needed so that a computer program read therefrom is installed into the storage section 708 as needed.

In particular, the processes described above with reference to the flowcharts may be implemented as computer software programs in accordance with the disclosed embodiments of the present invention. For example, embodiments disclosed herein include a computer program product comprising a computer program carried on a computer-readable medium, the computer program containing program code for performing the method illustrated in the flowchart. In such an embodiment, the computer program may be downloaded and installed from the network via the communication portion 709 and/or installed from the removable medium 711 . When the computer program is executed by the central processing unit (CPU) 701, the above-described functions defined in the system of the present invention are executed.

It should be noted that the computer-readable medium shown in the present invention may be a computer-readable signal medium or a computer-readable storage medium, or any combination of the above two. The computer-readable storage medium can be, for example, but not limited to, an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus or device, or a combination of any of the above. More specific examples of computer readable storage media may include, but are not limited to, electrical connections with one or more wires, portable computer disks, hard disks, random access memory (RAM), read only memory (ROM), erasable Programmable read only memory (EPROM or flash memory), fiber optics, portable compact disk read only memory (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination of the foregoing. In the present invention, a computer-readable storage medium may be any tangible medium that contains or stores a program that can be used by or in conjunction with an instruction execution system, apparatus, or device. In the present invention, however, a computer-readable signal medium may include a data signal propagated in baseband or as part of a carrier wave, carrying computer-readable program code therein. Such propagated data signals may take a variety of forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination of the foregoing. A computer-readable signal medium can also be any computer-readable medium other than a computer-readable storage medium that can transmit, propagate, or transport the program for use by or in connection with the instruction execution system, apparatus, or device . Program code embodied on a computer readable medium may be transmitted using any suitable medium including, but not limited to, wireless, wireline, optical fiber cable, RF, etc., or any suitable combination of the foregoing.

The flowchart and block diagrams in the Figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods and computer program products according to various embodiments of the present invention. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of code that contains one or more logical functions for implementing the specified functions executable instructions. It should also be noted that, in some alternative implementations, the functions noted in the blocks may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It is also noted that each block of the block diagrams or flowchart illustrations, and combinations of blocks in the block diagrams or flowchart illustrations, can be implemented in special purpose hardware-based systems that perform the specified functions or operations, or can be implemented using A combination of dedicated hardware and computer instructions is implemented.

The modules involved in the embodiments of the present invention may be implemented in a software manner, and may also be implemented in a hardware manner. The described modules can also be provided in the processor, for example, it can be described as: a processor includes a receiving module, a building module, a determining module and a feedback module. Among them, the names of these modules do not constitute a limitation of the module itself under certain circumstances, for example, the receiving module can also be described as "used to respond to the client in the distributed version control system to submit the code successfully message, call the control The tester receives the test software through the web application programming interface”.

As another aspect, the present invention also provides a computer-readable medium, which may be included in the device described in the above embodiments; or may exist alone without being assembled into the device. The above-mentioned computer-readable medium carries one or more programs, and when the above-mentioned one or more programs are executed by a device, the device includes:

In response to the successful message of the client submitting the code in the distributed version control system, the controller is invoked to receive the test software through the network application programming interface, and the test software includes the client production resource file and the source code resource file;

Build a server-side production resource file according to the production resource code of the source code resource file;

It is determined that the client production resource file is consistent with the server production resource file, and the code snapshot of the source code resource file is consistent with the code snapshot of the historical source code resource file;

A browser is used to load the test software, and based on the displayed content of the browser, the test results of the test software are fed back.

According to the technical solution of the embodiment of the present invention, in response to the successful message of the code submitted by the client in the distributed version control system, the controller is invoked to receive the test software through the network application programming interface, and the test software includes the client production resource file and the source code. code resource file; build a server-side production resource file according to the production resource code of the source code resource file; determine that the client-side production resource file is consistent with the server-side production resource file, and the code of the source code resource file The snapshot is consistent with the code snapshot of the historical source code resource file; the browser is used to load the test software, and based on the displayed content of the browser, the test results of the test software are fed back. By comparing the production resource files, it is judged that the production environment is the same, and the code snapshots are compared to ensure that the existing code is consistent, and then the test software is loaded in the browser to feedback the test results. The above process is performed automatically without manual intervention, thereby improving the efficiency of software testing.

The above-mentioned specific embodiments do not constitute a limitation on the protection scope of the present invention. It should be understood by those skilled in the art that various modifications, combinations, sub-combinations and substitutions may occur depending on design requirements and other factors. Any modifications, equivalent replacements and improvements made within the spirit and principle of the present invention shall be included within the protection scope of the present invention.

Claims (10)

1. A method of testing software, comprising:

responding to a successful code submitting message of a client in the distributed version control system, calling a controller to receive test software through a network application programming interface, wherein the test software comprises a client production resource file and a source code resource file;

according to the production resource codes of the source code resource file, a server production resource file is constructed;

determining that the client production resource file is consistent with the server production resource file, and the code snapshot of the source code resource file is consistent with the code snapshot of the historical source code resource file;

and loading the test software by adopting a browser, and feeding back a test result of the test software based on the display content of the browser.

2. The method for testing software according to claim 1, wherein before the responding to the client submitting the code success message in the distributed version control system, further comprising:

associating the test software with the distributed version control system, the distributed version control system receiving the test software.

3. The method for testing software according to claim 1, wherein the constructing a server-side production resource file according to the production resource code of the source code resource file comprises:

and installing the production resource file corresponding to the production resource code according to the production resource code of the source code resource file so as to construct a production resource file of the server.

4. The method for testing software according to claim 1, wherein the code snapshot of the source code resource file is consistent with the code snapshot of the historical source code resource file in the server, comprising:

based on the version identification of the source code resource file, a historical code resource file is appointed in a server;

acquiring a code snapshot of the source code resource file and a code snapshot of the historical source code resource file by adopting a browsing simulator and respectively combining the source code resource file and the appointed historical source code resource file;

and determining that the code snapshot of the source code resource file is consistent with the code snapshot of the historical source code resource file in the server.

5. The method for testing software according to claim 4, wherein said designated historical code resource file comprises the historical code resource file most recent to said version identification.

6. The method for testing software according to claim 1, wherein the loading the testing software by using a browser and feeding back the testing result of the testing software based on the display content of the browser comprises:

and executing the test software by adopting a browser, and feeding back a test result of the test software based on the display content of a browser rendering page, wherein the rendering page is a specified page in the source code resource file.

7. The method for testing software according to claim 1, wherein the loading the test software by using a browser and feeding back the test result of the test software based on the display content of the browser comprises:

loading the test software by adopting a browser, and failing to render and display content based on the browser;

and redirecting the loading request of the browser to a backup server, and feeding back the test result of the test software by reloading the test software in the backup server.

8. An apparatus for testing software, comprising:

the system comprises a receiving module, a code generating module and a code generating module, wherein the receiving module is used for responding to a successful code submitting message of a client in the distributed version control system, calling a controller to receive test software through a network application programming interface, and the test software comprises a client production resource file and a source code resource file;

the construction module is used for constructing a server side production resource file according to the production resource codes of the source code resource file;

the determining module is used for determining that the client side production resource file is consistent with the server side production resource file, and the code snapshot of the source code resource file is consistent with the code snapshot of the historical source code resource file;

and the feedback module is used for loading the test software by adopting a browser and feeding back a test result of the test software based on the display content of the browser.

9. An electronic device for testing software, comprising:

one or more processors;

a storage device for storing one or more programs,

when executed by the one or more processors, cause the one or more processors to implement the method of any one of claims 1-7.

10. A computer-readable medium, on which a computer program is stored, which, when being executed by a processor, carries out the method according to any one of claims 1-7.

Images