CN110647460B - Test resource management method and device and test client - Google Patents
Test resource management method and device and test client Download PDFInfo
- Publication number
- CN110647460B CN110647460B CN201910717969.3A CN201910717969A CN110647460B CN 110647460 B CN110647460 B CN 110647460B CN 201910717969 A CN201910717969 A CN 201910717969A CN 110647460 B CN110647460 B CN 110647460B
- Authority
- CN
- China
- Prior art keywords
- test
- resource
- resources
- client
- requested
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/3668—Software testing
- G06F11/3672—Test management
- G06F11/3688—Test management for test execution, e.g. scheduling of test suites
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Computer Hardware Design (AREA)
- Quality & Reliability (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Debugging And Monitoring (AREA)
- Information Retrieval, Db Structures And Fs Structures Therefor (AREA)
Abstract
The embodiment of the application provides a test resource management method, a device and a test client, wherein the method comprises the following steps: the sharing server receives test resources uploaded by a first test client based on the execution process of the test case; the sharing server persistently stores the received test resources into a database; when the sharing server receives a resource acquisition request of the second test client, responding to the resource acquisition request, acquiring the requested test resource from the database and returning the test resource to the second test client. By the method, the problem that the existing test clients need to store and update the test resources respectively and the storage and update pressures and loads are heavier is solved, and the technical effects of reducing the backup and update pressures of the test resources are achieved.
Description
Technical Field
The present application relates to the field of internet technologies, and in particular, to a method and an apparatus for managing test resources, and a test client.
Background
The existing test cases and test resources are generally stored and managed under a test framework, and in this case, the increase of the test cases leads to the increase of the test resources, so that the resource management becomes more and more complex. The test resources are required to be backed up when the test cases are backed up, which also tends to increase the backup pressure.
Furthermore, at present, the test cases and the test resources are one by one, and each person independently updates the own test resources, so that the synchronization of the test resources becomes complex, when the test resources change, the code and the resources updated by the person need to be submitted first, then all the test cases with influences need to be updated and backed up, and then the test cases are uploaded to a server, and at the moment, other persons can perform synchronous updating operation again, and then the test cases can be re-executed.
In view of the above problems, no effective solution has been proposed at present.
Disclosure of Invention
The embodiment of the application provides a test resource management method, a device and a test client, which are used for solving the technical problems that the existing test resource storage, synchronization and other operation processes are too complicated and the efficiency is low.
In one aspect, a method for managing test resources is provided, the method comprising:
the sharing server receives test resources uploaded by a first test client based on the execution process of the test case;
the sharing server persistently stores the received test resources into a database;
when the sharing server receives a resource acquisition request of the second test client, responding to the resource acquisition request, acquiring the requested test resource from the database and returning the test resource to the second test client.
In one embodiment, the test cases execute text, pictures, video used in the process, and execution logs and test reports;
the resource types of the test resources include: the test resources of the information class and the test resources of the file class; and
the sharing server persists the received test resources to a database, including:
the sharing server durably stores the test resources of the information class into a redis database or a mysql database;
and the sharing server durably stores the test resources of the file class into a file data database.
In one embodiment, the sharing server, in response to the resource obtaining request, obtains the requested test resource from the database and returns the test resource to the second test client, including:
the sharing server reads identification information from the resource acquisition request;
the sharing server determines the test case and/or the file type corresponding to the requested test resource according to the identification information;
the sharing server acquires the requested test resources from the database according to the determined test cases and/or file types;
and the sharing server sends the acquired test resources to the second test client.
In one embodiment, before the sharing server receives the resource acquisition request of the second test client, the method further includes:
the second test client judges whether a preset interface is opened or not;
the second test client sends the resource acquisition request to the sharing server under the condition that the interface is open;
under the condition that the interface is not opened, the second client determines whether the local cache is cached with the requested test resource;
under the condition that the local cache is cached with the requested test resource, acquiring the requested test resource from the local cache;
and under the condition that the requested test resources are not cached in the local cache, the second test client side sends prompt information to the shared server, wherein the prompt information is used for prompting the shared server to open the interface, and under the condition that the interface is open, the second test client side sends the resource acquisition request to the shared server.
In one embodiment, after the sharing server obtains the requested test resource from the database and returns the test resource to the second test client, the sharing server further includes:
and the second test client caches the test resources returned by the shared server according to the resource type.
In another aspect, there is provided a test resource management apparatus, located in a shared server, comprising:
the first receiving module is used for receiving the test resources uploaded by the first test client side in the execution process of the test case;
the storage module is used for storing the received test resources into the database in a lasting manner;
and the return module is used for responding to the resource acquisition request when receiving the resource acquisition request of the second test client, acquiring the requested test resource from the database and returning the test resource to the second test client.
In one embodiment, the test resources include: text, pictures and videos used in the test case execution process, and an execution log and a test report;
the resource types of the test resources include: the test resources of the information class and the test resources of the file class; and
the memory module includes:
the first storage unit is used for storing the test resources of the information class into a redis database or a mysql database in a lasting mode;
and the second storage unit is used for storing the test resources of the file class into the file data database in a lasting mode.
In one embodiment, the return module includes:
a reading unit for reading the identification information from the resource acquisition request;
the determining unit is used for determining the test case and/or the file type corresponding to the requested test resource according to the identification information;
the acquisition unit is used for acquiring the requested test resources from the database according to the determined test cases and/or file types;
and the sending unit is used for sending the acquired test resources to the second test client.
In yet another aspect, a test client is provided, including:
the judging module is used for judging whether a preset interface is opened or not before sending a resource acquisition request to the sharing server;
the first sending module is used for sending the resource acquisition request to the sharing server under the condition that the interface is opened;
the determining module is used for determining whether the requested test resource is cached in the local cache under the condition that the interface is not opened;
the acquisition module is used for acquiring the requested test resource from the local cache under the condition that the requested test resource is cached in the local cache;
the second sending module is configured to send a prompt message to the shared server when the requested test resource is not cached in the local cache, where the prompt message is used to prompt the shared server to open the interface, and send the resource acquisition request to the shared server when the interface is open.
In one embodiment, the test client further includes:
and the caching module is used for caching the test resources returned by the sharing server according to the resource types after the sharing server acquires the requested test resources from the database and returns the test resources to the test client.
The technical scheme has the following beneficial effects: the method has the advantages that the sharing server is arranged, the first testing client can upload the execution process based on the testing case to the sharing server, and other testing clients can acquire the testing resources uploaded by the first testing client from the sharing server, so that on one hand, the backup of the testing resources on the sharing server is realized, and on the other hand, the testing clients can share the testing resources. By the method, the problem that the existing test clients need to store and update the test resources respectively and the storage and update pressures and loads are heavier is solved, and the technical effects of reducing the backup and update pressures of the test resources are achieved.
Drawings
In order to more clearly illustrate the embodiments of the application or the technical solutions in the prior art, the drawings that are required in the embodiments or the description of the prior art will be briefly described, it being obvious that the drawings in the following description are only some embodiments of the application, and that other drawings may be obtained according to these drawings without inventive effort for a person skilled in the art.
FIG. 1 is a block diagram of a test resource management system according to an embodiment of the present application;
FIG. 2 is a flow chart of a method for testing resource management according to an embodiment of the present application;
FIG. 3 is a schematic diagram of a test resource management architecture according to an embodiment of the present application;
FIG. 4 is a block diagram illustrating a test resource management device according to an embodiment of the present application;
fig. 5 is a block diagram of a test client according to an embodiment of the present application.
Detailed Description
The following description of the embodiments of the present application will be made clearly and completely with reference to the accompanying drawings, in which it is apparent that the embodiments described are only some embodiments of the present application, but not all embodiments. All other embodiments, which can be made by those skilled in the art based on the embodiments of the application without making any inventive effort, are intended to be within the scope of the application.
Considering that the existing test cases and test resources are one, each person independently updates the own test resources, so that the synchronization of the test resources becomes complex, when the test resources change, the code and the resources updated by the person need to be submitted first, then all the test cases with influences need to be updated and backed up, and then the test cases are uploaded to a server, and then other people can execute the test cases again through the changed test resources after the synchronous update operation.
In view of the foregoing, in this example, there is provided a test resource management system, as shown in fig. 1, which may include: the test clients 101 can upload test resources of the test clients based on the execution process of the test cases to the shared server 102 for storage, and other test clients can acquire the test resources from the shared server 102, so that synchronous update can be realized, and the effect of realizing one-time storage through the storage of the shared server can be realized.
Based on the above test resource management system, in this example, there is also provided a test resource management method, as shown in fig. 2, which may include the following steps:
step 201: the sharing server receives test resources uploaded by a first test client based on the execution process of the test case;
the first test client may be any one of the clients in the test resource management system, and the test resources uploaded by the first test client may be queued for uploading by a queue.
Step 202: the sharing server persistently stores the received test resources into a database;
the shared server may store the test resources uploaded by each client according to the characteristic of queue first-in-first-out. That is, if the test resource uploaded by the first test client is queued, the shared server stores the resource.
Furthermore, considering that for the existing test case, after each execution, the test resources such as the execution log and the like are stored locally, but the persistent management is not performed on the test resources, so that the history log is easy to lose, and other people cannot check the execution log of the user, so that the future test has no history basis.
For this reason, in this embodiment, after the shared server acquires the test resource, the acquired test resource may be stored in a persistent manner, so that when the test resource needs to be called or referred to later, the test resource may be referred to effectively. In particular, the shared server may persist the test resources to a database.
Step 203: when the sharing server receives a resource acquisition request of the second test client, responding to the resource acquisition request, acquiring the requested test resource from the database and returning the test resource to the second test client.
After the first test client stores the test resources in the shared server, other clients can acquire the test resources from the shared server, so that the clients do not need to maintain one part by one person, and the storage requirement is greatly reduced.
In the above example, a sharing server is set, the first test client can upload the execution process based on the test case to the sharing server, and other test clients can acquire the test resources uploaded by the first test client from the sharing server, so that on one hand, backup of the test resources on the sharing server is realized, and on the other hand, the test clients can share the test resources. By the method, the problem that the existing test clients need to store and update the test resources respectively and the storage and update pressures and loads are heavier is solved, and the technical effects of reducing the backup and update pressures of the test resources are achieved.
When the persistent storage of the test resource is actually performed, the sharing server can classify and store the test resource in consideration of the diversity of data types in the test resource, for example, the test resource of the information class can be persistently stored in redis and mysql; and storing the test resources of the file class into a file data database in a lasting manner. It should be noted, however, that the specific example of the classification storage is merely an exemplary description, and the classification storage may be performed in other manners when actually implemented, which is not limited by the present application.
The test resources may include: text, pictures and videos used in the test case execution process, and an execution log and a test report; for these test resources, there may be multiple resource types, such as: the test resources of the information class and the test resources of the file class exist in the form of information, such as parameters and the like needed by the test, which exist in the form of single information, and the test resources of the file class exist in the form of files, such as texts, test reports and the like, which are files which can be directly called and checked.
In order to achieve efficient acquisition of test resources, the resource acquisition request may carry identification information, where the identification information is used to identify which test resource of which test case the client requests to acquire, or which type of test resource. Based on the identification information, the shared server can accurately locate the test resources to be acquired. Specifically, the providing, by the sharing server, the test resource to the second test client in response to the resource obtaining request may include: the sharing server reads the identification information from the resource acquisition request; the sharing server determines the test case and/or the file type corresponding to the requested test resource according to the identification information; the sharing server acquires the requested test resources from the database according to the determined test cases and/or file types; and the sharing server sends the acquired test resources to the second test client.
When actually implemented, the resource management service may perform interface packaging, and be exposed to the client so that the client uploads the test resource or obtains the test resource. Specifically, the receiving, by the sharing server, the resource acquisition request of the second test client may include: the second test client judges whether a preset interface is opened or not; the second test client sends the resource acquisition request to the sharing server under the condition that the interface is open; under the condition that the interface is not opened, the second test client determines whether the test resource is cached in the local cache; under the condition that the test resources are cached in the local cache, acquiring the test resources from the local cache; and under the condition that the test resources are not cached in the local cache, the second test client side sends prompt information to the shared server, wherein the prompt information is used for prompting the shared server to open the interface, and under the condition that the interface is open, the second test client side sends the resource acquisition request to the shared server.
That is, it may be first determined whether the interface is open, if so, the test resource is directly obtained from the shared server, if not, the test resource is obtained from the local cache, and if not, the interface is requested from the shared server to obtain the test resource from the shared server.
The interface may be installed into the test client in the form of an SDK, that is, by implementing the installation of the interface according to the corresponding SDK.
In the above example, because the test resources are not fixed, the problem of test case failure caused by adopting the fixed test resources can be avoided, and the problems of history log loss, incapability of referring and the like can be avoided by performing persistence processing on the test resources such as the log and the like.
The above method is described below in connection with a specific embodiment, however, it should be noted that this specific embodiment is only for better illustrating the present application and is not meant to be a undue limitation on the present application.
In this example, a test resource management system is provided, as shown in fig. 3, which may include: the system comprises a data acquisition module, a resource management module, a storage module and an SDK, wherein:
and the data acquisition module is used for uploading the test resources by the user, writing the test resources into the data queue and waiting for the acquisition of the server.
The resource management module is used for carrying out logic processing on the test resource data when a user uploads the test resource or reads the test resource in the data queue, and storing the processed data; when the user acquires the test resource, data is acquired from the database and returned to the user.
The storage module is used for storing the test resources, and can be stored in a classified mode according to different resource types, for example, the test resources of the information class can be stored in redis and mysql, and the test resources of the file class can be stored in file data.
The SDK can realize two services of the flash shell and the java, package the resource management service through an interface, and expose the interface to the client for uploading and acquiring the test resource. Through the interface, local cache storage can be performed for the client, classified storage can be performed for the server on the acquired resources, and for example, up to 20 test resources of the file class in the local cache can be controlled. Further, a server-dependent switch may be disposed on the SDK, and when turned on, the client obtains the test resource from the server and performs local caching; when the switch is closed, the client directly tests the resources from the local cache, and if the local cache does not have the test resources, the client prompts the server to open the switch, so that the stability of automatic test is ensured.
The method can be applied to a message box platform, a multimedia platform, an open platform and the like of the microblog, and the cost of accessing resources can be reduced by the method without independently collecting the test resources; when the test is finished, the execution results, the execution log and other test resources are uploaded to the shared server, and the testers and the developers can review the history records and reserve the test basis.
By the scheme, the test resources can be managed in real time, and the test resources are changed without modifying the test codes; the test resources can be shared, and when one person uploads the test resources, the test cases of other persons can also use the test resources; furthermore, the code and the test resource are separated, so that the burden of the code management server is reduced. The test log and the report can be stored in a lasting mode, on one hand, the test case execution waiting time of a tester is liberated, a developer can check the test result, and on the condition that no problem is found, the online operation can be directly carried out without inquiring the test result. On the other hand, log loss due to certain improper operations is reduced. Namely, the SpringBoot framework is used for realizing test resource management, uniformly managing test resources of testers and reporting logs, and carrying out resource sharing strategies, so that the problems of losing and updating the test resources are solved, the management of files is greatly facilitated, and the basis is reserved for future tests.
Based on the same inventive concept, the embodiment of the application also provides a test resource management device, as described in the following embodiment. Since the principle of the test resource management device for solving the problem is similar to that of the test resource management method, the implementation of the test resource management device can refer to the implementation of the test resource management method, and the repetition is omitted. As used below, the term "unit" or "module" may be a combination of software and/or hardware that implements the intended function. While the means described in the following embodiments are preferably implemented in software, implementation in hardware, or a combination of software and hardware, is also possible and contemplated. Fig. 4 is a block diagram of a test resource management device according to an embodiment of the present application, which is located in a shared server, and as shown in fig. 4, may include: the structure of the receiving module 401, the storing module 402, and the returning module 403 will be described below.
A receiving module 401, configured to receive a test resource uploaded by a first test client in an execution process of a test case;
a storage module 402, configured to persist the received test resources to a database;
and the return module 403 is configured to, when receiving a resource acquisition request of the second test client, respond to the resource acquisition request, acquire the requested test resource from the database and return the test resource to the second test client.
Furthermore, considering that for the existing test case, after each execution, the test resources such as the execution log and the like are stored locally, but the persistent management is not performed on the test resources, so that the history log is easy to lose, and other people cannot check the execution log of the user, so that the future test has no history basis.
For this reason, in this embodiment, after the shared server acquires the test resource, the acquired test resource may be stored in a persistent manner, so that when the test resource needs to be called or referred to later, the test resource may be referred to effectively. In particular, the shared server may persist the test resources to a database.
In one embodiment, the test resources may include: text, pictures and videos used in the test case execution process, and an execution log and a test report; the resource types of the test resource may include: the test resources of the information class and the test resources of the file class; and the storage module 402 may include: the first storage unit is used for storing the test resources of the information class into a redis database or a mysql database in a lasting mode; and the second storage unit is used for storing the test resources of the file class into the file class database in a lasting manner.
In one embodiment, the return module 403 may include: a reading unit for reading the identification information from the resource acquisition request; the determining unit is used for determining the test case and/or the file type corresponding to the requested test resource according to the identification information; the acquisition unit is used for acquiring the requested test resources from the database according to the determined test cases and/or file types; and the sending unit is used for sending the acquired test resources to the second test client.
In this example, there is also provided a test client, as shown in fig. 5, which may include the following modules:
a judging module 501, configured to judge whether a preset interface is open before sending a resource acquisition request to a shared server;
a first sending module 502, configured to send the resource obtaining request to the sharing server when the interface is open;
a determining module 503, configured to determine, if the interface is not opened, whether the local cache has the requested test resource cached therein;
an obtaining module 504, configured to obtain, in the case where the local cache has a requested test resource cached therein, the requested test resource from the local cache;
and the second sending module 505 is configured to send a prompt message to the shared server when the requested test resource is not cached in the local cache, where the prompt message is used to prompt the shared server to open the interface, and send the resource acquisition request to the shared server when the interface is open.
In one embodiment, the test client may further include: and the caching module is used for caching the test resources returned by the sharing server according to the resource types after the sharing server acquires the requested test resources from the database and returns the test resources to the test client.
In the above example, a sharing server is set, the first test client can upload the execution process based on the test case to the sharing server, and other test clients can acquire the test resources uploaded by the first test client from the sharing server, so that on one hand, backup of the test resources on the sharing server is realized, and on the other hand, the test clients can share the test resources. By the method, the problem that the existing test clients need to store and update the test resources respectively and the storage and update pressures and loads are heavier is solved, and the technical effects of reducing the backup and update pressures of the test resources are achieved.
Those of skill in the art will further appreciate that the various illustrative logical blocks (illustrative logical block), units, and steps described in connection with the embodiments of the application may be implemented by electronic hardware, computer software, or combinations of both. To clearly illustrate this interchangeability of hardware and software, various illustrative components (illustrative components), elements, and steps have been described above generally in terms of their functionality. Whether such functionality is implemented as hardware or software depends upon the particular application and design requirements of the overall system. Those skilled in the art may implement the described functionality in varying ways for each particular application, but such implementation is not to be understood as beyond the scope of the embodiments of the present application.
The various illustrative logical blocks or units described in the embodiments of the application may be implemented or performed with a general purpose processor, a digital signal processor, an Application Specific Integrated Circuit (ASIC), a field programmable gate array or other programmable logic device, discrete gate or transistor logic, discrete hardware components, or any combination thereof designed to perform the functions described. A general purpose processor may be a microprocessor, but in the alternative, the general purpose processor may be any conventional processor, controller, microcontroller, or state machine. A processor may also be implemented as a combination of computing devices, e.g., a digital signal processor and a microprocessor, a plurality of microprocessors, one or more microprocessors in conjunction with a digital signal processor core, or any other similar configuration.
The steps of a method or algorithm described in connection with the embodiments disclosed herein may be embodied directly in hardware, in a software module executed by a processor, or in a combination of the two. A software module may be stored in RAM memory, flash memory, ROM memory, EPROM memory, EEPROM memory, registers, hard disk, a removable disk, a CD-ROM, or any other form of storage medium known in the art. In an example, a storage medium may be coupled to the processor such that the processor can read information from, and write information to, the storage medium. In the alternative, the storage medium may be integral to the processor. The processor and the storage medium may reside in an ASIC, which may reside in a user terminal. In the alternative, the processor and the storage medium may reside as distinct components in a user terminal.
In one or more exemplary designs, the above-described functions of embodiments of the present application may be implemented in hardware, software, firmware, or any combination of the three. If implemented in software, the functions may be stored on a computer-readable medium or transmitted as one or more instructions or code on the computer-readable medium. Computer readable media includes both computer storage media and communication media that facilitate transfer of computer programs from one place to another. A storage media may be any available media that can be accessed by a general purpose or special purpose computer. For example, such computer-readable media may include, but is not limited to, RAM, ROM, EEPROM, CD-ROM or other optical disk storage, magnetic disk storage or other magnetic storage devices, or any other medium that may be used to carry or store program code in the form of instructions or data structures and other data structures that may be read by a general or special purpose computer, or a general or special purpose processor. Further, any connection is properly termed a computer-readable medium, e.g., if the software is transmitted from a website, server, or other remote source via a coaxial cable, fiber optic cable, twisted pair, digital Subscriber Line (DSL), or wireless such as infrared, radio, and microwave, and is also included in the definition of computer-readable medium. The disks (disks) and disks (disks) include compact disks, laser disks, optical disks, DVDs, floppy disks, and blu-ray discs where disks usually reproduce data magnetically, while disks usually reproduce data optically with lasers. Combinations of the above may also be included within the computer-readable media.
The foregoing description of the embodiments has been provided for the purpose of illustrating the general principles of the application, and is not meant to limit the scope of the application, but to limit the application to the particular embodiments, and any modifications, equivalents, improvements, etc. that fall within the spirit and principles of the application are intended to be included within the scope of the application.
Claims (9)
1. A method of testing resource management, the method comprising:
the sharing server receives test resources uploaded by a first test client based on the execution process of the test case;
the sharing server persistently stores the received test resources into a database; when the sharing server receives a resource acquisition request of a second test client, responding to the resource acquisition request, acquiring the requested test resource from the database and returning the test resource to the second test client;
before the sharing server receives the resource acquisition request of the second test client, the sharing server further comprises:
the second test client judges whether a preset interface is opened or not;
the second test client sends the resource acquisition request to the sharing server under the condition that the interface is open;
under the condition that the interface is not opened, the second test client determines whether the local cache has the requested test resource;
under the condition that the local cache is cached with the requested test resource, acquiring the requested test resource from the local cache;
and under the condition that the requested test resources are not cached in the local cache, the second test client side sends prompt information to the shared server, wherein the prompt information is used for prompting the shared server to open the interface, and under the condition that the interface is open, the second test client side sends the resource acquisition request to the shared server.
2. The method of claim 1, wherein the testing resources comprises: text, pictures and videos used in the test case execution process, and an execution log and a test report;
the resource types of the test resources include: the test resources of the information class and the test resources of the file class; and
the sharing server persists the received test resources to a database, including:
the sharing server durably stores the test resources of the information class into a redis database or a mysql database;
and the sharing server durably stores the test resources of the file class into a filedata database.
3. The method of claim 1, wherein the sharing server, in response to the resource acquisition request, acquires the requested test resource from the database and returns to the second test client, comprising:
the sharing server reads identification information from the resource acquisition request;
the sharing server determines the test case and/or the file type corresponding to the requested test resource according to the identification information;
the sharing server acquires the requested test resources from the database according to the determined test cases and/or file types;
and the sharing server sends the acquired test resources to the second test client.
4. The method of claim 1, wherein after the shared server obtains the requested test resource from the database and returns the test resource to the second test client, further comprising:
and the second test client caches the test resources returned by the shared server according to the resource type.
5. A test resource management apparatus comprising a shared server and a test client, the shared server comprising:
the receiving module is used for receiving the test resources uploaded by the first test client in the execution process of the test case; the storage module is used for storing the received test resources into the database in a lasting manner; the return module is used for responding to the resource acquisition request when receiving the resource acquisition request of the second test client, acquiring the requested test resource from the database and returning the test resource to the second test client;
the test client comprises:
the judging module is used for judging whether a preset interface is opened or not before sending a resource acquisition request to the sharing server; the first sending module is used for sending the resource acquisition request to the sharing server under the condition that the interface is opened; the determining module is used for determining whether the requested test resource is cached in the local cache under the condition that the interface is not opened; the acquisition module is used for acquiring the requested test resource from the local cache under the condition that the requested test resource is cached in the local cache; the second sending module is configured to send a prompt message to the shared server when the requested test resource is not cached in the local cache, where the prompt message is used to prompt the shared server to open the interface, and send the resource acquisition request to the shared server when the interface is open.
6. The apparatus of claim 5, wherein the test resources comprise: text, pictures and videos used in the test case execution process, and an execution log and a test report;
the resource types of the test resources include: the test resources of the information class and the test resources of the file class; and
the memory module includes:
the first storage unit is used for storing the test resources of the information class into a redis database or a mysql database in a lasting mode;
and the second storage unit is used for storing the test resources of the file class into the filedata database in a lasting mode.
7. The apparatus of claim 5, wherein the return module comprises:
a reading unit for reading the identification information from the resource acquisition request;
the determining unit is used for determining the test case and/or the file type corresponding to the requested test resource according to the identification information;
the acquisition unit is used for acquiring the requested test resources from the database according to the determined test cases and/or file types;
and the sending unit is used for sending the acquired test resources to the second test client.
8. A test client, comprising:
the judging module is used for judging whether a preset interface is opened or not before sending a resource acquisition request to the sharing server;
the first sending module is used for sending the resource acquisition request to the sharing server under the condition that the interface is opened;
the determining module is used for determining whether the requested test resource is cached in the local cache under the condition that the interface is not opened;
the acquisition module is used for acquiring the requested test resource from the local cache under the condition that the requested test resource is cached in the local cache;
the second sending module is configured to send a prompt message to the shared server when the requested test resource is not cached in the local cache, where the prompt message is used to prompt the shared server to open the interface, and send the resource acquisition request to the shared server when the interface is open.
9. The test client of claim 8, further comprising:
and the caching module is used for caching the test resources returned by the sharing server according to the resource types after the sharing server acquires the requested test resources from the database and returns the test resources to the test client.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201910717969.3A CN110647460B (en) | 2019-08-05 | 2019-08-05 | Test resource management method and device and test client |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201910717969.3A CN110647460B (en) | 2019-08-05 | 2019-08-05 | Test resource management method and device and test client |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN110647460A CN110647460A (en) | 2020-01-03 |
| CN110647460B true CN110647460B (en) | 2023-09-05 |
Family
ID=68990016
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201910717969.3A Active CN110647460B (en) | 2019-08-05 | 2019-08-05 | Test resource management method and device and test client |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN110647460B (en) |
Families Citing this family (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN111654549B (en) * | 2020-06-11 | 2022-11-08 | 浙江浙大网新国际软件技术服务有限公司 | Automatic safety testing method based on function testing |
| CN112003976B (en) * | 2020-07-31 | 2022-04-29 | 北京达佳互联信息技术有限公司 | Hard-coding and hard-decoding test method and device |
| CN113515453B (en) * | 2021-06-24 | 2021-12-07 | 航天中认软件测评科技（北京）有限责任公司 | Webpage testing system |
| CN117493218B (en) * | 2023-12-27 | 2024-03-22 | 南京翼辉信息技术有限公司 | VSOA-based test system and test method |
Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US5628005A (en) * | 1995-06-07 | 1997-05-06 | Microsoft Corporation | System and method for providing opportunistic file access in a network environment |
| CN101321179A (en) * | 2008-01-08 | 2008-12-10 | 华为技术有限公司 | Method, device and system for implementing resource sharing |
| CN102231686A (en) * | 2011-06-24 | 2011-11-02 | 北京天融信科技有限公司 | System and method for implementing automated test of network security equipment |
| CN102880546A (en) * | 2012-09-03 | 2013-01-16 | 上海方正数字出版技术有限公司 | Software integration testing method and system based on extensible markup language (XML) database |
| CN104219262A (en) * | 2013-05-30 | 2014-12-17 | 好看科技（深圳）有限公司 | Media resource sharing system and method, server cluster and video player |
Family Cites Families (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US10608954B2 (en) * | 2016-03-11 | 2020-03-31 | Ciena Corporation | Hierarchical resource tree allocation |
| US11431634B2 (en) * | 2017-05-24 | 2022-08-30 | Lenovo (Singapore) Pte. Ltd. | Client device and resource manager load sharing |
-
2019
- 2019-08-05 CN CN201910717969.3A patent/CN110647460B/en active Active
Patent Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US5628005A (en) * | 1995-06-07 | 1997-05-06 | Microsoft Corporation | System and method for providing opportunistic file access in a network environment |
| CN101321179A (en) * | 2008-01-08 | 2008-12-10 | 华为技术有限公司 | Method, device and system for implementing resource sharing |
| CN102231686A (en) * | 2011-06-24 | 2011-11-02 | 北京天融信科技有限公司 | System and method for implementing automated test of network security equipment |
| CN102880546A (en) * | 2012-09-03 | 2013-01-16 | 上海方正数字出版技术有限公司 | Software integration testing method and system based on extensible markup language (XML) database |
| CN104219262A (en) * | 2013-05-30 | 2014-12-17 | 好看科技（深圳）有限公司 | Media resource sharing system and method, server cluster and video player |
Also Published As
| Publication number | Publication date |
|---|---|
| CN110647460A (en) | 2020-01-03 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN110647460B (en) | Test resource management method and device and test client | |
| US10412170B2 (en) | Retention-based data management in a network-based data store | |
| CN108712457B (en) | Method and device for adjusting dynamic load of back-end server based on Nginx reverse proxy | |
| CN113254466B (en) | Data processing method and device, electronic equipment and storage medium | |
| CN107370806B (en) | HTTP status code monitoring method, device, storage medium and electronic equipment | |
| CN108540533B (en) | Request answering method and device | |
| US9910881B1 (en) | Maintaining versions of control plane data for a network-based service control plane | |
| CN110460584B (en) | Access request processing method and device, electronic equipment and computer readable medium | |
| CN109039787A (en) | log processing method, device and big data cluster | |
| CN109597724B (en) | Service stability measuring method, device, computer equipment and storage medium | |
| CN111200637B (en) | Cache processing method and device | |
| CN113076251A (en) | Test method and device | |
| CN112416708A (en) | Asynchronous call link monitoring method and system | |
| CN107403112B (en) | Data checking method and equipment thereof | |
| CN112084114B (en) | Method and apparatus for testing interfaces | |
| CN107315672B (en) | Method and device for monitoring server | |
| US20150205675A1 (en) | Method and System for Improving Reliability of a Background Page | |
| CN115705190A (en) | Method and device for determining dependence degree | |
| CN115883647B (en) | Service log recording method, system, device, terminal, server and medium | |
| CN116541461A (en) | Data processing method, device, equipment and storage medium applied to database | |
| US12020039B2 (en) | Compute instance warmup operations | |
| CN115168203A (en) | Interface simulation method, device, system, computer equipment and storage medium | |
| CN114116646A (en) | Log data processing method, device, equipment and storage medium | |
| CN113852610A (en) | Message processing method and device, computer equipment and storage medium | |
| CN109144788B (en) | Method, device and system for reconstructing OSD |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |