Off-site multi-source test data processing method, test equipment and computer program product
By preprocessing and extracting key feature data locally at the service node, the problem of large data volume and slow speed in data aggregation across multiple service nodes in different locations is solved, achieving efficient and accurate data aggregation and analysis. The use of large models improves the efficiency and accuracy of data export.
Patent Information
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- CHENGDU BIWIN STORAGE TECHNOLOGY CO LTD
- Filing Date
- 2025-12-26
- Publication Date
- 2026-05-29
AI Technical Summary
In existing technologies, during the process of aggregating test data from multiple service nodes in different locations, the original test data is not accurate enough, contains a large amount of redundant data, has a large data volume, slow export speed, and low efficiency, resulting in a large workload for data analysis.
The raw test data is preprocessed and key features are extracted locally at each service node. The central node aggregates the requests and returns only the extracted key feature data. The large model is used for data analysis, which reduces the amount of data and improves the aggregation speed and accuracy.
It significantly reduces data transmission volume, improves data export speed and the accuracy and efficiency of merging data sources from multiple service nodes, and leverages the analytical capabilities of large models without the need to train massive models independently, thus gaining up-to-date AI capabilities.
Smart Images
Figure CN122111992A_ABST
Abstract
Description
Technical Field
[0001] This application relates to the field of data testing, and in particular to a method, testing equipment, and computer program product for processing multi-source test data in different locations. Background Technology
[0002] The testing platform can be used to verify the correctness and reliability of software or systems. Currently, the testing platform service is deployed in multiple regions, with each service node deploying independent system services and its own database to execute test project tasks and store raw test data for local test cases.
[0003] When a user needs to obtain test data for all test cases of a specific test project on the testing platform, service nodes in different locations export the raw test data to the user for aggregation. However, because the raw test data is not accurate enough and contains a large amount of redundant data, the data volume is large, the export speed is slow, the export efficiency is low, and the data analysis workload is heavy, requiring significant export and processing time. Summary of the Invention
[0004] This application provides a method, testing equipment, and computer program product for processing multi-source test data from different locations, in order to improve the accuracy of merging data sources from multiple service nodes and the efficiency of data export.
[0005] In a first aspect, embodiments of this application provide a method for processing multi-source test data in different locations, wherein the method is applied to at least one service node, and the method includes: The raw test data of multiple test cases related to the test project are collected locally at each service node, and the raw test data is preprocessed and key features are extracted. In response to the data aggregation request from the central node, the key feature data extracted by each service node is returned to the central node; Each of the service nodes is configured as a central node or a remote node. The central node is a service node that is locally connected to the user terminal, and the remote node is a service node that is remotely connected to the central node.
[0006] By implementing the embodiments of this application, since the service nodes in various locations preprocess and extract key features from the original test data locally, when remote nodes respond to the user terminal with data aggregation requests through the central node, they only need to return the extracted key feature data instead of the original test data. This not only effectively utilizes the powerful computing capabilities of the service nodes in various locations, distributing the data preprocessing and key feature extraction tasks to each remote node for execution, but also ensures that the returned key feature data accurately matches the requirements and does not contain redundant data, greatly reducing the amount of data, accelerating the data aggregation speed, and improving the accuracy of merging data sources from multiple service nodes and the efficiency of data export.
[0007] In at least one possible implementation, prior to the data aggregation request in response to the central node, the method further includes: In response to the central node's status polling request, each service node queries its node working status and returns the node working status information it queried to the central node; and / or When extracting key features from the original test data, the process also includes: Synchronously update the node working status information of this service node, which includes the task execution status and data extraction progress of this service node; and / or Before collecting the raw test data of multiple test cases related to the test project locally on each service node, the process also includes: Responding to data collection commands from the central node.
[0008] In at least one possible implementation, after key feature extraction is performed on the original test data, the method further includes: The key features extracted from the original test data are written into the key feature dataset of the test project in the user directory corresponding to the service node. After synchronizing and updating the node working status information of the service node, the following is also included: The synchronously updated node working status information of the service node is written into the node working status information set of the test project in the user directory corresponding to the service node.
[0009] Secondly, embodiments of this application provide a method for processing multi-source test data from different locations, which is applied to a user terminal. The method includes: Send data aggregation instructions to multiple service nodes; Receive key feature data returned from the multiple service nodes, the key feature data being extracted locally on each service node from the original test data of multiple test cases related to the test project; After summarizing and processing the key data features returned by the multiple service nodes, the large model is invoked, and a test quality analysis report for the test project is generated based on the summarized key feature data.
[0010] Implementing the embodiments of this application, on the one hand, fully utilizes the independent computing capabilities of service nodes in various locations, preprocessing and extracting key features from the original test data locally. When remote nodes respond to data aggregation requests from the central node to the user terminal, they only return the extracted key feature data. This achieves the distribution of data preprocessing and key feature extraction tasks to various remote nodes for execution. The aggregated key feature data accurately matches the requirements and does not contain redundant data, greatly reducing the amount of data, accelerating the data aggregation speed, improving the accuracy of merging data sources from multiple service nodes, and increasing data export efficiency. On the other hand, by utilizing the data analysis capabilities of large models, the platform does not need to train and deploy a large model itself to obtain up-to-date AI capabilities in the application. At the same time, the powerful data analysis and processing capabilities of large models can also help to remove more redundant data, further simplify key feature data, and further reduce the amount of data.
[0011] In at least one possible implementation, prior to sending the data aggregation instruction to the multiple service nodes, the method further includes: The working status of multiple service nodes is polled according to preset polling conditions until the working status of the nodes reaches the preset data aggregation conditions. The node's working status is obtained by querying the node working status information of the service node, which is synchronously updated by each service node. The node working status information includes the task execution status and data extraction progress of the service node.
[0012] In at least one possible implementation, before polling the user status of multiple service nodes according to preset polling conditions, the method further includes: Send data collection instructions to each service node.
[0013] Thirdly, embodiments of this application provide a method for processing multi-source test data from different locations. This method is applied to a test platform and includes: Each service node collects raw test data of multiple test cases related to the test project locally, and performs preprocessing and key feature extraction on the raw test data. The service nodes include a central node and remote nodes. The central node is a service node connected to the user's local terminal, and the remote nodes are service nodes connected to the central node in a different location. The central node sends a data aggregation request to each remote node. Each remote node returns the user key feature data extracted by the remote node to the central node; After the user client summarizes and processes the key user data features returned by the multiple service nodes, it calls the large model and generates a test quality analysis report for the test project based on the summarized key feature data.
[0014] Implementing the embodiments of this application, on the one hand, fully utilizes the independent computing capabilities of service nodes in various locations, preprocessing and extracting key features from the original test data locally. When remote nodes respond to data aggregation requests from the central node to the user terminal, they only return the extracted key feature data. This achieves the distribution of data preprocessing and key feature extraction tasks to various remote nodes for execution. The aggregated key feature data accurately matches the requirements and does not contain redundant data, greatly reducing the amount of data, accelerating the data aggregation speed, improving the accuracy of merging data sources from multiple service nodes, and increasing data export efficiency. On the other hand, by utilizing the data analysis capabilities of large models, the platform does not need to train and deploy a large model itself to obtain up-to-date AI capabilities in the application. At the same time, the powerful data analysis and processing capabilities of large models can also help to remove more redundant data, further simplify key feature data, and further reduce the amount of data.
[0015] In at least one possible implementation, before the central node sends a data aggregation request to each remote node, the method further includes: The working status of multiple service nodes is polled according to preset polling conditions until the working status of the nodes meets the preset data aggregation conditions.
[0016] In at least one possible implementation, before polling the node working status of multiple service nodes according to preset polling conditions, the method further includes: In response to the central node's status polling request, each service node queries its node working status and returns the node working status information it queried to the central node; and / or When extracting key features from the original test data, the process also includes: Synchronously update the node working status information of this service node, which includes the task execution status and data extraction progress of this service node; and / or Responding to data collection commands from the central node.
[0017] In at least one possible implementation, after key feature extraction is performed on the original test data, the method further includes: The key features extracted from the original test data are written into the key feature dataset of the test project in the user directory corresponding to the service node. After synchronizing and updating the node working status information of the service node, the following is also included: The synchronously updated node working status information of the service node is written into the node working status information set of the test project in the user directory corresponding to the service node.
[0018] In at least one possible implementation, the key feature data includes: test project name, test capacity, test duration, number of failures for each test version, and reason for failure.
[0019] Fourthly, embodiments of this application provide a testing device including a processor and a memory, the memory being coupled to the processor, the memory being used to store computer program code, the computer program code including computer instructions, and when the processor reads the computer instructions from the memory, causing the processor to execute the steps in the remote multi-source test data processing method as described in the first, second, or third aspects.
[0020] Fifthly, embodiments of this application provide a computer program product, the computer program product comprising: computer program code, which, when executed on a computer, causes the computer to perform the steps in the remote multi-source test data processing method as described in the first, second, or third aspects.
[0021] The beneficial effects of this application are: This application embodiment fully utilizes the computing power of independent service nodes in various locations. The original test data of test cases related to the test project are preprocessed and key features are extracted locally on each service node. When the user needs to aggregate the data, the remote nodes only return the key features extracted from the original test data of the local test cases to the user through the central node, so that the user can call the large model for data analysis. This significantly reduces the amount of data transmission, greatly improves the data export speed, the accuracy of merging data sources from multiple service nodes, and the efficiency of data export. Attached Figure Description
[0022] To more clearly illustrate the technical solutions in the embodiments of this application or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.
[0023] Figure 1 This is a schematic diagram of the architecture of the test platform according to an embodiment of this application.
[0024] Figure 2 This is a flowchart illustrating one embodiment of the multi-source test data processing method in this application.
[0025] Figure 3 This is a flowchart illustrating one embodiment of the multi-source test data processing method in this application.
[0026] Figure 4 This is a flowchart illustrating one embodiment of the multi-source test data processing method in this application.
[0027] Figure 5 This is a schematic diagram of the structure of one embodiment of the test device according to the present application. Detailed Implementation
[0028] To make the objectives, technical solutions, and advantages of this application clearer, the technical solutions of this application will be described in detail below with reference to the accompanying drawings in the embodiments of this application. Obviously, the described embodiments are only some, not all, of the embodiments of this application. Unless otherwise specified, the embodiments and features in the embodiments of this application can be combined with each other. Based on the embodiments of this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.
[0029] It should be noted that: throughout the accompanying drawings, the same or similar reference numerals denote the same or similar elements or elements having the same or similar functions; in the description of this application, the terms "center," "longitudinal," "lateral," "front," "rear," "left," "right," "vertical," "horizontal," "top," "bottom," "inner," and "outer," etc., indicate the orientation or positional relationship based on the orientation or positional relationship shown in the accompanying drawings, and are only for the convenience of describing this application and simplifying the description, and do not indicate or imply that the device or element referred to must have a specific orientation, or be constructed and operated in a specific orientation, and therefore should not be construed as a limitation on the scope of protection of this application; in the description of this application, "first," "second," etc., are only used to distinguish each other, and do not indicate their degree of importance or order, etc.
[0030] In the description of this application, unless otherwise expressly specified and limited, the terms "installation," "connection," and "linkage" should be interpreted broadly. For example, they can refer to fixed connections, movable connections, or detachable connections; they can refer to mechanical connections or electrical connections; they can refer to direct connections or indirect connections through an intermediate medium; they can refer to the internal communication between two components, etc. Those skilled in the art can understand the specific meaning of the above terms in this application based on the specific circumstances.
[0031] For example, please refer to Figure 1 The test platform of this application includes multiple service nodes deployed in various regions. One service node is locally connected to the user terminal. The user terminal connects to other service nodes remotely through the service node connected to its local terminal, sending instructions to and receiving data from multiple remote nodes. The service node locally connected to the user terminal is designated as the central node, and the other service nodes remotely connected to the local node are designated as remote nodes.
[0032] To address issues such as network instability across multiple nodes in different locations within the intranet, the current testing platform deploys independent system services and their databases in multiple regions. Users can aggregate test data for all test cases within a specific test project as needed. This includes key data such as the number of failures, reasons for failure, test size, and test duration for each test version of a particular test project within the past year. This data is used to analyze test case effectiveness and execution efficiency, generating test quality analysis reports. In existing technologies, during data aggregation, service nodes in different locations aggregate raw test data to the central node. The cleaning and processing of this raw test data are all performed at the central node. Therefore, this requires not only robust transmission capabilities between the service nodes and the central node, but also powerful data processing capabilities from the central node itself.
[0033] To address the above issues, this application provides a method for processing multi-source test data from different locations. Please refer to [link / reference]. Figure 2 The multi-source test data processing method is applied to at least one service node, and the method includes: In step S101, raw test data of multiple test cases related to the test project are collected locally at each service node, and the raw test data is preprocessed and key features are extracted. In step S102, in response to the data aggregation request from the central node, the key feature data extracted by each service node is returned to the central node; Each of the service nodes is configured as a central node or a remote node. The central node is a service node that is locally connected to the user terminal, and the remote node is a service node that is remotely connected to the central node.
[0034] By implementing the embodiments of this application, the independent computing capabilities of service nodes in various locations are fully utilized. The original test data is preprocessed and key features are extracted locally in advance. When remote nodes respond to the data aggregation request to the user terminal through the central node, they only return the extracted key feature data. This realizes the distribution of data preprocessing and key feature extraction tasks to various remote nodes for execution. The aggregated key feature data accurately matches the requirements and does not contain redundant data, which greatly reduces the amount of data, speeds up the data aggregation, improves the accuracy of merging data sources from multiple service nodes, and increases the efficiency of data export.
[0035] In at least one possible implementation, prior to the data aggregation request in response to the central node, the method further includes: In step S1011, in response to the status polling request of the central node, each service node queries its node working status and returns the node working status information queried by the service node to the central node.
[0036] In at least one possible implementation, when extracting key features from the original test data, the method further includes: In step S1012, the node working status information of the service node is updated synchronously. The node working status information includes the task execution status and data extraction progress of the test project on the service node.
[0037] By synchronously updating the working status when extracting key features, when the central node polls the working status of the service nodes, it can obtain the working status, task execution status and data preparation progress of the service nodes simply by querying the node working status information, without having to follow up on the task throughout the entire process, effectively saving query time and improving query efficiency.
[0038] In at least one possible implementation, before collecting the raw test data of multiple test cases related to the test project locally at each service node, the method further includes: In step S1010, the data collection command from the central node is responded to.
[0039] Each service node can pre-extract key features from its local raw test data to save response time; or it can extract key features from its local raw test data after receiving data collection instructions from the central node to save computing power.
[0040] In at least one possible implementation, after key feature extraction is performed on the original test data, the method further includes: The key features extracted from the original test data are written into the key feature dataset of the test project in the user directory corresponding to the service node. After synchronizing and updating the node working status information of the service node, the following is also included: The synchronously updated node working status information of the service node is written into the node working status information set of the test project in the user directory corresponding to the service node.
[0041] Configuring a user directory for each test project on each service node can prevent multiple clients from simultaneously publishing tasks, which could lead to errors caused by multiple clients operating on the same file at the same time.
[0042] Since the progress is updated multiple times during the key feature data extraction process, if the key feature data and node working status data are placed together, there may be a risk of errors caused by writing two sets of data at the same time. To avoid this risk, the data is divided into two independent files in a user directory: Key Feature Dataset and Key Feature Dataset.
[0043] This application also provides a method for processing multi-source test data from different locations. Please refer to [link / reference]. Figure 3 The method for processing multi-source test data in different locations is applied to the user end, and the method includes: In step S201, a data aggregation command is sent to multiple service nodes; In step S202, key feature data returned from the multiple service nodes is received. The key feature data is extracted locally on each service node from the original test data of multiple test cases related to the test project. In step S203, after summarizing the key data features returned by the multiple service nodes, the large model is invoked, and a test quality analysis report for the test project is generated based on the summarized key feature data.
[0044] Implementing the embodiments of this application, on the one hand, fully utilizes the independent computing capabilities of service nodes in various locations, preprocessing and extracting key features from the original test data locally. When remote nodes respond to data aggregation requests from the central node to the user terminal, they only return the extracted key feature data. This achieves the distribution of data preprocessing and key feature extraction tasks to various remote nodes for execution. The aggregated key feature data accurately matches the requirements and does not contain redundant data, greatly reducing the amount of data, accelerating the data aggregation speed, improving the accuracy of merging data sources from multiple service nodes, and increasing data export efficiency. On the other hand, by utilizing the data analysis capabilities of large models, the platform does not need to train and deploy a large model itself to obtain up-to-date AI capabilities in the application. At the same time, the powerful data analysis and processing capabilities of large models can also help to remove more redundant data, further simplify key feature data, and further reduce the amount of data.
[0045] In at least one possible implementation, prior to sending the data aggregation instruction to the multiple service nodes, the method further includes: In step S2011, the node working status of multiple service nodes is polled according to preset polling conditions until the node working status reaches the preset data aggregation conditions. The node's working status is obtained by querying the node working status information of the test project, which is synchronously updated by each service node. The node working status information includes the task execution status and data extraction progress of the service node.
[0046] In at least one possible implementation, before polling the user status of multiple service nodes according to preset polling conditions, the method further includes: In step S2010, a data collection instruction is sent to each service node.
[0047] Based on the same concept in the above embodiments, this application also provides a method for processing multi-source test data in different locations. This method is applied to a test platform. Please refer to [link / reference needed]. Figure 4 The method includes: In step S1, each service node collects raw test data of multiple test cases related to the test project locally, and performs preprocessing and key feature extraction on the raw test data. The service nodes include a central node and remote nodes. The central node is a service node connected locally to the user terminal, and the remote nodes are service nodes connected remotely to the central node. In step S2, the user terminal sends a data aggregation request to each remote node through the central node; In step S3, each remote node returns the user key feature data extracted by the remote node to the central node; In step S4, after the user terminal summarizes and processes the key user data features returned by the multiple service nodes, it calls the large model and generates a test quality analysis report for the test project based on the summarized key feature data.
[0048] Implementing the embodiments of this application, on the one hand, fully utilizes the independent computing capabilities of service nodes in various locations, preprocessing and extracting key features from the original test data locally. When remote nodes respond to data aggregation requests from the central node to the user terminal, they only return the extracted key feature data. This achieves the distribution of data preprocessing and key feature extraction tasks to various remote nodes for execution. The aggregated key feature data accurately matches the requirements and does not contain redundant data, greatly reducing the amount of data, accelerating the data aggregation speed, improving the accuracy of merging data sources from multiple service nodes, and increasing data export efficiency. On the other hand, by utilizing the data analysis capabilities of large models, the platform does not need to train and deploy a large model itself to obtain up-to-date AI capabilities in the application. At the same time, the powerful data analysis and processing capabilities of large models can also help to remove more redundant data, further simplify key feature data, and further reduce the amount of data.
[0049] This application has at least the following advantages: It significantly improves the efficiency of conducting analysis on test case effectiveness and test case execution efficiency, and generates test quality analysis reports, while reducing the cost of data transmission, processing, and analysis; Improve the accuracy of merging data sources across multiple service nodes and the efficiency of data export; Leveraging the data analysis capabilities of large-scale models allows for early prediction of potential problems, timely feedback and adjustments, and effective risk mitigation.
[0050] In at least one possible implementation, before the central node sends a data aggregation request to each remote node, the method further includes: In step S21, the central node polls the node working status of multiple service nodes according to preset polling conditions until the node working status reaches the preset data aggregation conditions.
[0051] In at least one possible implementation, before polling the node working status of multiple service nodes according to preset polling conditions, the method further includes: In step S12, in response to the status polling request of the central node, each service node queries its node working status and returns the node working status information queried by the service node to the central node.
[0052] In at least one possible real-time method, when extracting key features from the original test data, the method further includes: In step S11, the node working status information of the service node is synchronously updated, including the task execution status and data extraction progress of the service node; and / or In step S10, in response to the data collection command from the central node.
[0053] In at least one possible implementation, after key feature extraction is performed on the original test data, the method further includes: The key features extracted from the original test data are written into the key feature dataset of the test project in the user directory corresponding to the service node. After synchronizing and updating the node working status information of the service node, the following is also included: The synchronously updated node working status information of the service node is written into the node working status information set of the test project in the user directory corresponding to the service node.
[0054] In at least one possible implementation, the key feature data includes: test project name, test capacity, test duration, number of failures for each test version, and reason for failure.
[0055] The following is an exemplary description of the specific process of performing a remote multi-source test data processing method in this embodiment.
[0056] Task triggering phase: The user selects the product_class of the corresponding test project, extracts the corresponding test cases based on the product_class, and triggers the data processing process of each service node.
[0057] Processing flow for each service node: The central node distributes the `product_class` and task triggering instructions to service nodes in other regions. Each service node processes the data independently, first transforming the raw test data into a feature dataset that meets the specified conditions. This fully utilizes the computing power of each service node. For example, every 500 test cases, relevant data is collected, key feature sets are extracted, processed into a predetermined data structure, and written to the user directory of the corresponding test project on that service node. Write key feature data into the key feature dataset data.json, for example: upload a minimal feature signature / data digest; and synchronously update the corresponding project status dataset staus.json in the user's directory, for example: update the status of the corresponding project status dataset staus.json to "pass" (indicating that the test project has passed) and the progress to "100%" (indicating that the key data extraction is complete).
[0058] Configuring a user directory for each test project on each service node can prevent multiple clients from simultaneously publishing tasks, which could lead to errors caused by multiple clients operating on the same file at the same time.
[0059] Because the progress of test case data is updated multiple times during data sharding, if the data and status data are placed together, there is a risk that the two data may be written at the same time, causing an error. In order to avoid this risk, the data is divided into two independent files, data.json and status.json, in a user directory.
[0060] Status monitoring phase: The client performs cyclical status monitoring of all service nodes (i.e., retrieving the status.json file in the user's directory for each service node), for example, polling every 10 seconds to retrieve the status.json of all service nodes until all service nodes reach "100%" progress. During the status monitoring process, the central node can synchronize the collected progress of each service node to the client at preset time intervals.
[0061] Data aggregation stage: When all nodes are at 100% progress, the central node triggers data aggregation, downloads the data.json files from each service node, aggregates and merges the data, and generates a complete dataset that meets the expected structure.
[0062] Data preparation stage: After obtaining the key feature datasets of all service nodes, the user end performs data preprocessing and formatting to generate highly condensed structured analysis results and construct precise Prompt instructions. For example, the key feature data may include test information, test duration, number of failures, reasons for failure, etc., for multiple disks in the test cases of the test project.
[0063] AI analysis phase: Through standard application programming interfaces (APIs), users can remotely access and use large-scale language models in the cloud. The constructed Prompt commands are input into the large model for processing and analysis, and the analysis results are verified. If the analysis quality is qualified, a business insight report (quality analysis report) is generated. If the analysis quality is unqualified, the Prompt commands need to be adjusted and optimized, and the large model API needs to be called again for processing and analysis until the analysis quality is qualified.
[0064] Report generation stage: If the analysis quality is satisfactory, a structured and executable test quality analysis report will be generated. For example, the report may include: an overall assessment of test quality, in-depth analysis of failure causes, test market performance analysis, optimization suggestions, and risk assessments, so that after delivery to relevant personnel, problems can be identified and the testing process optimized.
[0065] Based on the same concept as the above embodiments, please refer to Figure 5 This application embodiment also provides a testing device, including a processor 100 and a memory 200. The memory 100 is coupled to the processor 200. The memory 200 is used to store computer program code, which includes computer instructions. When the processor 100 reads the computer instructions from the memory 200, the processor 100 executes the steps in the remote multi-source test data processing method of any possible implementation of the above embodiments.
[0066] This application also provides a computer program product, which includes computer program code. When the computer program code is run on a computer, it causes the computer to perform the steps in the remote multi-source test data processing method of any possible implementation of the above embodiments.
[0067] Those skilled in the art will recognize that the functions described in the embodiments of this application in one or more of the above examples can be implemented using hardware, software, firmware, or any combination thereof. When implemented using software, these functions can be stored in a computer-readable medium or transmitted as one or more instructions or code on a computer-readable medium. Computer-readable media include computer storage media and communication media, wherein communication media include any medium that facilitates the transfer of a computer program from one place to another. Storage media can be any available medium that can be accessed by a general-purpose or special-purpose computer.
[0068] Note that the above are merely preferred embodiments and the technical principles employed in this application. Those skilled in the art will understand that this application is not limited to the specific embodiments described herein, and various obvious changes, readjustments, and substitutions can be made without departing from the scope of protection of this application. Therefore, although this application has been described in detail through the above embodiments, this application is not limited to the above embodiments, and may include many other equivalent embodiments without departing from the concept of this application, the scope of which is determined by the scope of the appended claims.
Claims
1. A method for processing multi-source test data from different locations, characterized in that, The multi-source test data processing method is applied to at least one service node, and the method includes: The raw test data of multiple test cases related to the test project are collected locally at each service node, and the raw test data is preprocessed and key features are extracted. In response to the data aggregation request from the central node, the key feature data extracted by each service node is returned to the central node; Each of the service nodes is configured as a central node or a remote node. The central node is a service node that is locally connected to the user terminal, and the remote node is a service node that is remotely connected to the central node.
2. The method for processing multi-source test data in different locations according to claim 1, characterized in that, Prior to responding to the data aggregation request from the central node, the following is also included: In response to the central node's status polling request, each service node queries its node working status and returns the node working status information it queried to the central node; and / or The process of extracting key features from the original test data also includes: Synchronously update the node working status information of this service node, which includes the task execution status and data extraction progress of this service node; and / or Before collecting the raw test data of multiple test cases related to the test project locally on each service node, the process also includes: Responding to data collection commands from the central node.
3. The method for processing multi-source test data in different locations according to claim 2, characterized in that, After key feature extraction from the original test data, the following is also included: The key features extracted from the original test data are written into the key feature dataset of the test project in the user directory corresponding to the service node. After synchronizing and updating the node working status information of the service node, the following is also included: The synchronously updated node working status information of the service node is written into the node working status information set of the test project in the user directory corresponding to the service node.
4. A method for processing multi-source test data from different locations, characterized in that, The method for processing multi-source test data from different locations is applied to the user end, and the method includes: Send data aggregation instructions to multiple service nodes; Receive key feature data returned from the multiple service nodes, the key feature data being extracted locally on each service node from the original test data of multiple test cases related to the test project; After summarizing and processing the key data features returned by the multiple service nodes, the large model is invoked, the summarized key feature data is input, and a test quality analysis report for the test project is generated.
5. The multi-source test data processing method according to claim 4, characterized in that, Before sending the data aggregation instruction to multiple service nodes, the method further includes: The working status of multiple service nodes is polled according to preset polling conditions until the working status of the nodes reaches the preset data aggregation conditions. The node's working status is obtained by querying the node working status information of that service node, which is synchronously updated by each service node. This node working status information includes the task execution status and data extraction progress of that service node; and / or Before sending the data aggregation instruction to multiple service nodes, the method further includes: Send data collection instructions to each service node.
6. A method for processing multi-source test data from different locations, characterized in that, The multi-source test data processing method is applied to a test platform, and the method includes: Each service node collects raw test data of multiple test cases related to the test project locally, and performs preprocessing and key feature extraction on the raw test data. The service nodes include a central node and / or remote nodes. The central node is a service node connected locally to the user terminal, and the remote nodes are service nodes connected remotely to the central node. The central node sends a data aggregation request to each remote node. Each remote node returns the key feature data extracted by the remote node to the central node; After the user client summarizes and processes the key data features returned by the multiple service nodes, it calls the large model, inputs the summarized key feature data, and generates a test quality analysis report for the test project.
7. The method for processing multi-source test data in different locations according to claim 6, characterized in that, Before the central node sends data aggregation requests to each remote node, the following is also included: The working status of multiple service nodes is polled according to preset polling conditions until the working status of the nodes meets the preset data aggregation conditions.
8. The method for processing multi-source test data in different locations according to claim 7, characterized in that, Before polling the node working status of multiple service nodes according to preset polling conditions, the method further includes: In response to the central node's status polling request, each service node queries its node working status and returns the node working status information it queried to the central node; and / or When extracting key features from the original test data, the process also includes: Synchronously update the node working status information of this service node, which includes the task execution status and data extraction progress of this service node; and / or Responding to data collection commands from the central node.
9. The method for processing multi-source test data in different locations according to claim 8, characterized in that, After key feature extraction from the original test data, the following is also included: The key features extracted from the original test data are written into the key feature dataset of the test project in the user directory corresponding to the service node. After synchronizing and updating the node working status information of the service node, the following is also included: The synchronously updated node working status information of the service node is written into the node working status information set of the test project in the user directory corresponding to the service node.
10. The method for processing multi-source test data in different locations according to claim 7, characterized in that, The key feature data includes: test project name, test capacity, test duration, number of failures for each test version, and reason for failure.
11. A testing device, characterized in that, It includes a processor and a memory coupled to the processor. The memory is used to store computer program code, which includes computer instructions. When the processor reads the computer instructions from the memory, the processor performs the steps in the remote multi-source test data processing method as described in any one of claims 1-10.
12. A computer program product, characterized in that, The computer program product includes: computer program code, which, when run on a computer, causes the computer to perform the steps in the remote multi-source test data processing method as described in any one of claims 1-10.