Multi-system collaborative code change risk assessment system and method of large model fusion

Abstract

The application relates to a multi-system collaborative code change risk assessment system and method of a large model fusion. The system comprises: a research and development process platform module for generating an application product and a corresponding product construction configuration; a quality research and development expansion module for generating a product information table according to the application product and the corresponding pipeline construction configuration; further used for extracting code submission records associated with the application product, merging and assembling layer by layer in a predetermined order to generate a business code change set, and inputting the business code change set into a large model based on a preset unit test scene prompt word to automatically generate corresponding unit test code; further used for performing unit testing on the application product based on the unit test code according to a preset running mechanism strategy, and the preset running mechanism strategy comprises a queuing strategy, a work area management strategy and a communication cooperation strategy. The application can accurately filter the actual changes of the application product, combine the large model to more accurately generate effective unit test code, and improve the test quality and iteration efficiency of the application product.

Description

Technical Field

[0001] This application relates to the field of computer information processing, and more specifically, to a multi-system collaborative code change risk assessment system and method that integrates a large model. Background Technology

[0002] In the research and development and testing of application artifacts, accurate identification of code changes, effective assessment of the impact of changes, and sufficient provision of executable unit tests are crucial to ensuring the quality of application versions and the efficiency of iteration. However, existing technologies still have several shortcomings in test management and code change analysis: First, code coverage lacks sufficient correlation with business requirements. Current projects generally rely on the JaCoCo tool to detect test code coverage, but its coverage depends only on the scope of test case execution and cannot establish a correspondence between "code blocks, business requirements, and the application they belong to." Developers and testers can only rely on experience to judge key scenarios, making it difficult to accurately locate the business source of code changes or distinguish changes from different applications in a shared repository, thus hindering the achievement of accurate test coverage.

[0003] Secondly, the impact assessment of changes remains superficial. Current version assessments rely heavily on statistical data such as the number and density of defects, lacking in-depth analysis of actual code changes. This makes it impossible to identify potential risks such as adjustments to method logic, interface impacts, or violations of business rules, and the assessment results fail to accurately reflect the actual scope of the version change's impact.

[0004] Secondly, there is an insufficient supply of unit test cases, and their executability is poor. Analysis of over 200 applications with Sonar scanning enabled shows that most unit test coverage is close to 0%. Although some projects have unit test cases, their execution is highly dependent on specific environments and related systems, often failing to be identified and utilized due to execution failures. Developers lack the motivation to write more executable unit tests, resulting in a lack of reliable material support for automated testing.

[0005] In summary, existing technologies have significant shortcomings in terms of code-business correlation, change impact analysis, and unit test case validity. There is an urgent need for a technical solution that can accurately correlate code with business, deeply assess the impact of changes, and efficiently generate executable unit tests to improve the testing quality and iteration efficiency of application artifacts.

[0006] The information disclosed in the background section is only intended to enhance the understanding of the background of this application, and therefore may include information that does not constitute prior art known to those skilled in the art. Summary of the Invention

[0007] In view of this, this application provides a multi-system collaborative code change risk assessment system and method that integrates a large model, which can accurately filter actual changes to application artifacts, generate effective unit test code more accurately by combining the large model, and improve the testing quality and iteration efficiency of application artifacts.

[0008] Other features and advantages of this application will become apparent from the following detailed description, or may be learned in part from practice of this application.

[0009] According to one aspect of this application, a multi-system collaborative code change risk assessment system integrating a large model is proposed. This system includes: a development process platform module for generating application artifacts and their corresponding artifact build configurations; a quality development extension module for generating an artifact information table based on the application artifacts and their corresponding pipeline build configurations; further configured to extract code submission records associated with the application artifacts, merge and assemble them layer by layer in a predetermined order to generate a set of business code changes, and input the set of business code changes into a large model based on preset unit test scenario prompts to automatically generate corresponding unit test code; further configured to perform unit tests on the application artifacts based on the unit test code according to a preset operating mechanism strategy, the preset operating mechanism strategy including: queuing strategy, workspace management strategy, and communication collaboration strategy; and a quality development auxiliary module for obtaining preset analysis scenario prompts; inputting the preset analysis scenario prompts and the set of business code changes into the large model, combining them with a business knowledge base to perform code change impact analysis, and generating a risk assessment report.

[0010] Optionally, it also includes: a quality R&D support module, used to perform code change impact analysis based on the business code change set by calling a large model combined with a business knowledge base, and generate a risk assessment report; and a quality management platform database, used to store the product information table, the application product code submission records, the business code change set, and the unit test code.

[0011] Optionally, the R&D process platform module is also used to build the application artifact and generate the artifact building configuration through the pipeline definition corresponding to the application artifact.

[0012] Optionally, the quality R&D expansion module includes: a synchronization unit, used to synchronize the application product and its corresponding pipeline construction configuration by the R&D process platform module; and also used to generate the product information table according to the application product and its corresponding pipeline construction configuration and preset rules, and store the product information table in the quality management platform database.

[0013] Optionally, the quality R&D expansion module includes: an extraction unit, configured to obtain a table of relationships between submission and change business codes; further configured to generate a set of associated code submission records based on the product information table and the table of relationships between submission and change business codes; and further configured to generate a set of application product business code changes based on the set of associated code submission records and the table of relationships between submission and change business codes.

[0014] Optionally, based on the set of associated code submission records and the table of submission and change business code relationships, the business code change set is obtained by merging them layer by layer according to branches, files, and methods.

[0015] Optionally, the quality R&D extension module includes: a large model unit, used to obtain preset unit test scenario prompts based on a queuing strategy; and also used to input the preset unit test scenario prompts and the business code change set into the large model in an asynchronous auxiliary manner to automatically generate corresponding unit test code for each class; and to manage the workspace through a predefined script.

[0016] Optionally, the quality R&D extension module includes: a testing unit, used to send unit test tasks to the Jenkins system based on the unit test code in an asynchronous manner, so that the Jenkins system can perform unit tests on the application artifact; and to control the execution of the unit tests through a queuing algorithm during the execution of the Jenkins system.

[0017] According to one aspect of this application, a multi-system collaborative code change risk assessment method integrating a large model is proposed. This method includes: obtaining application artifacts and their corresponding artifact build configurations; generating an artifact information table based on the application artifacts and their corresponding pipeline build configurations; extracting code commit records associated with the application artifacts and merging them layer by layer in a predetermined order to generate a business code change set; inputting the business code change set into a large model based on preset unit test scenario prompts to automatically generate corresponding unit test code; and performing unit tests on the application artifacts based on the unit test code according to a preset operating mechanism strategy, wherein the preset operating mechanism strategy includes: queuing strategy, workspace management strategy, and communication collaboration strategy.

[0018] According to one aspect of this application, an electronic device is provided, comprising: one or more processors; a storage device for storing one or more programs; and, when the one or more programs are executed by the one or more processors, causing the one or more processors to implement the method as described above.

[0019] According to one aspect of this application, a computer-readable medium is provided having a computer program stored thereon that, when executed by a processor, implements the method described above.

[0020] According to one aspect of this application, a computer program product is provided, comprising: a computer program / instructions that, when executed by a processor, implement the method as described above.

[0021] The multi-system collaborative code change risk assessment system and method based on the integrated large model of this application includes: a development process platform module for generating application artifacts and their corresponding artifact build configurations; a quality development extension module for generating artifact information tables based on application artifacts and their corresponding pipeline build configurations; an extraction of code submission records associated with the application artifacts, merging and assembling them layer by layer in a predetermined order to generate a set of business code changes, and inputting the set of business code changes into the large model based on preset unit test scenario prompts to automatically generate corresponding unit test code; and unit testing of the application artifacts based on the unit test code according to a preset operating mechanism strategy, which includes queuing strategies, workspace management strategies, and communication collaboration strategies, enabling accurate filtering of actual changes to application artifacts, and more accurate generation of effective unit test code in conjunction with the large model, thereby improving the testing quality and iteration efficiency of application artifacts.

[0022] It should be understood that the above general description and the following detailed description are merely exemplary and do not limit this application. Attached Figure Description

[0023] The above and other objects, features, and advantages of this application will become more apparent from the detailed description of exemplary embodiments with reference to the accompanying drawings. The drawings described below are merely some embodiments of this application, and those skilled in the art can obtain other drawings based on these drawings without any inventive effort.

[0024] Figure 1 This is a flowchart illustrating a multi-system collaborative code change risk assessment method that integrates a large model, according to an exemplary embodiment.

[0025] Figure 2 This is a flowchart illustrating a multi-system collaborative code change risk assessment method that integrates a large model, according to another exemplary embodiment.

[0026] Figure 3 This is a schematic diagram illustrating a multi-system collaborative code change risk assessment method that integrates a large model, according to another exemplary embodiment.

[0027] Figure 4 This is a schematic diagram illustrating a multi-system collaborative code change risk assessment method that integrates a large model, according to another exemplary embodiment.

[0028] Figure 5This is a block diagram illustrating a multi-system collaborative code change risk assessment system that integrates a large model, according to an exemplary embodiment.

[0029] Figure 6 This is a block diagram illustrating an electronic device according to an exemplary embodiment. Detailed Implementation

[0030] Exemplary embodiments will now be described more fully with reference to the accompanying drawings. However, these exemplary embodiments can be implemented in many forms and should not be construed as limited to the embodiments set forth herein; rather, they are provided so that this application will be thorough and complete, and will fully convey the concept of the exemplary embodiments to those skilled in the art. The same reference numerals in the drawings denote the same or similar parts, and therefore repeated descriptions of them will be omitted.

[0031] The technical abbreviations used in this application are explained as follows: QOA: Quality Management Platform; QOA-DB: Quality Management Platform Database; QOA-DEVOPS: Quality R&D Support Module; QOA-JOB-JAR: Quality R&D Extension Module; LINGXI: R&D process platform.

[0032] In actual software development, as project scale and code repository complexity increase, multiple applications often share the same code repository. This leads to blurred relationships between code changes and specific applications / versions, making it difficult to conduct artifact-level difference analysis and accurate testing. At the same time, the problem of insufficient number and incomplete coverage of unit test cases is common, making it difficult to detect change risks in a timely manner, affecting the stability of version delivery and development efficiency.

[0033] To address the aforementioned issues, this application proposes a multi-system collaborative code change risk assessment method that integrates a large-scale model. This method aims to solve the problems of low efficiency in code change identification, change impact assessment, and unit test (hereinafter referred to as "unit test") generation during the development and testing of application artifacts. This application analyzes precisely extracted business change code from the system, combining application repository branch information and code commit correlation data to achieve artifact-level change analysis for Java application iterations. Even in scenarios where multiple applications share the same code repository, it can effectively distinguish and isolate the actual change scope of each application, thereby achieving accurate identification and handling of changed code.

[0034] Based on this, this application focuses on "user submission behavior" as its starting point, establishing a precise correlation between the application and its iterative versions, and on this basis, achieving automated filtering and identification of artifact changes. Furthermore, by combining the natural language processing and code generation capabilities of the large model, it can conduct in-depth risk analysis of artifact changes, and automatically generate high-quality unit test code related to the actual changes, providing reliable test materials and risk basis for subsequent automated test execution.

[0035] This application mainly addresses and improves upon the following three technical issues: Application and code association identification problem: To address the issue that the artifact build process only contains branch information and lacks iteration version mapping, this problem is solved by maintaining application build information, locating build directory files, and introducing application association information in the task submission, so as to accurately associate code changes with specific iteration versions of specific applications.

[0036] Insufficient unit test coverage: To address the issue of scarce unit test cases that cannot effectively cover code changes, high-quality, executable unit test code is automatically generated based on the purified business change code of the system, using a large model to improve test coverage and execution efficiency.

[0037] Artifact-level change impact analysis: Addressing the lack of in-depth analysis of the impact of application artifact changes in existing technologies, this paper utilizes a large model to conduct artifact-level risk assessment of the potential impact of code changes from the perspective of code structure and logic changes, providing a scientific basis for version testing and quality control.

[0038] The technical content of this application will be described in detail below with the aid of actual embodiments.

[0039] Figure 1 This is a flowchart illustrating a multi-system collaborative code change risk assessment method for a fusion-based large model, according to an exemplary embodiment. The multi-system collaborative code change risk assessment method 10 for a fusion-based large model includes at least steps S102 to S112.

[0040] like Figure 1 As shown, in S102, the application artifact and its corresponding artifact build configuration are obtained. The application artifact is built through the R&D process platform module, and the artifact build configuration is generated through the pipeline definition corresponding to the application artifact.

[0041] The development process platform module can extract build scripts (such as Maven's pom.xml file) and build parameters from the project code repository to form the build configuration file of the application artifact, providing a structured information foundation for subsequent change identification.

[0042] In S104, a product information table is generated based on the application product and its corresponding production line configuration. For example, the R&D process platform module can synchronize the application product and its corresponding production line configuration; it is also used to generate the product information table based on the application product, its corresponding production line configuration, and preset rules, and store the product information table in the quality management platform database.

[0043] Specifically, the R&D process platform module can synchronize the application artifacts and their corresponding pipeline construction configuration information to the quality R&D extension module. The quality R&D extension module can generate an artifact information table according to preset rules. The information table may include data items such as application identifier, version number, branch name, construction path, and construction parameters, and can also store it in the quality management platform database for subsequent data association and querying.

[0044] It's worth noting that the synchronization of artifact information determines whether applications, iterations, and commits can be accurately and clearly identified. The most crucial aspect lies in the directory of the configuration file (pom.xml) in the build configuration. Assuming multiple applications share a code repository, it's highly likely that they will be differentiated using subdirectories on top of the root directory, such as qoa-app / pom.xml. Therefore, when extracting changes to files in this repository, the prefix "qoa-app" can be used for filtering, resulting in more accurate code changes and avoiding redundant and invalid data from interfering with subsequent operations.

[0045] In S106, code submission records associated with the application artifact are extracted and merged layer by layer in a predetermined order to generate a set of business code changes. For example, a table showing the relationship between submitted and changed business codes can be obtained; the system is also used to generate a set of associated code submission records based on the artifact information table and the table showing the relationship between submitted and changed business codes; and further used to generate a set of application artifact business code changes based on the set of associated code submission records and the table showing the relationship between submitted and changed business codes.

[0046] More specifically, based on the set of associated code commit records and the table of commit and change business code relationships, the business code change set is obtained by merging them layer by layer according to branches, files, and methods.

[0047] In one specific embodiment, a relationship table of submitted and modified business codes can be obtained first, and a set of code submission records can be generated based on the association information between the relationship table and the artifact information table. On this basis, the quality R&D extension module merges and assembles the submission records layer by layer according to the hierarchical relationship of branches, files, and methods, ultimately forming a set of business code changes corresponding to the application artifact.

[0048] This step enables the identification and filtering of changes across applications and branches, ensuring that the generated change set contains only valid code changes related to the target artifact.

[0049] More specifically, based on all change information of the corresponding system associated with the artifact, all code change blocks are integrated together according to the hierarchical relationship of branches, directories, files, and methods.

[0050] Change file information can be extracted from the package information of the class files whose design has been changed.

[0051] like Figure 3 As shown, corresponding directories can also be actively created based on the repository, branch, and package information of the artifact, and generated according to the files merged in the first step.

[0052] In S108, the set of business code changes is input into the large model based on preset unit test scenario prompts to automatically generate corresponding unit test code. For example, preset unit test scenario prompts can be obtained based on a queuing strategy; it can also be used to input the preset unit test scenario prompts and the set of business code changes into the large model in an asynchronous manner to automatically generate corresponding unit test code for each class; and the workspace is managed through a predefined script.

[0053] For example, the system can load preset unit test scenario prompt templates from the quality management platform database. The quality R&D extension module, based on an asynchronous task mechanism, inputs the prompts along with the set of business code changes into the large model, automatically generating unit test code files corresponding to each change class file. The generated unit test files can, for example, be stored in a specified shared storage path for use by the continuous integration platform.

[0054] In S110, unit tests of the application artifact are performed based on the unit test code according to a preset execution mechanism strategy. The preset execution mechanism strategy includes: a queuing strategy, a workspace management strategy, and a communication collaboration strategy. For example, unit test tasks can be sent to the Jenkins system based on the unit test code using asynchronous assistance, enabling the Jenkins system to perform unit tests on the application artifact; during the execution of the Jenkins system, the execution of the unit tests is controlled by a queuing algorithm.

[0055] Specifically, the system can send unit test tasks to the Jenkins system asynchronously based on the unit test code to trigger automated test execution. During test execution, the system uses a queuing algorithm to control task scheduling based on the running credentials, ensuring that unit test tasks of the same application and branch are executed sequentially, while tasks of different applications or branches can run in parallel, thereby improving execution efficiency while ensuring test independence.

[0056] In one specific embodiment, the R&D process platform module can pull the latest branch code of a Java application from the enterprise's internal code management system (such as GitLab) and generate a build configuration file for the application. The quality R&D extension module generates an artifact information table based on this build configuration and identifies the commit differences between the most recent build and the previous version build.

[0057] The system merges and assembles changes layer by layer according to a predetermined order based on discrepancies to generate a set of business code changes, which can include modifications to three class files. The quality development extension module inputs these change codes and corresponding prompts into the large model to automatically generate unit test code. The three generated unit test files are written to a shared storage directory.

[0058] In practical applications, unit test execution tasks can be automatically triggered via Jenkins. Because task scheduling uses a queuing algorithm, unit tests for different applications can be executed in parallel. After the tests are completed, the system automatically summarizes the results and generates test logs. If the system also enables the risk assessment module, it will call a large model to perform an impact analysis on the three changed classes. The output report shows that a change in one of the classes may affect the payment module's interface call logic, which can be used to increase the priority of regression testing for that module.

[0059] In step S112, based on the set of business code changes, a large model is invoked in conjunction with a business knowledge base to perform an impact analysis of the code changes, generating a risk assessment report. For example, preset analysis scenario prompts can be obtained; these prompts and the set of business code changes can be input into the large model, combined with the business knowledge base, to perform the impact analysis of the code changes and generate a risk assessment report.

[0060] According to the multi-system collaborative code change risk assessment method of the integrated large model in this application, the development process platform module is used to generate application artifacts and their corresponding artifact build configurations; the quality development extension module is used to generate an artifact information table based on the application artifacts and their corresponding pipeline build configurations; it is also used to extract code submission records associated with the application artifacts, merge and assemble them layer by layer in a predetermined order to generate a set of business code changes, and input the set of business code changes into the large model based on preset unit test scenario prompts to automatically generate corresponding unit test code; it is also used to perform unit tests on the application artifacts based on the unit test code according to a preset operating mechanism strategy. The preset operating mechanism strategy includes: queuing strategy, work area management strategy, and communication collaboration strategy, which can accurately filter the actual changes of the application artifacts, and generate effective unit test code more accurately in combination with the large model, thereby improving the testing quality and iteration efficiency of the application artifacts.

[0061] It should be clearly understood that this application describes how specific examples are formed and used, but the principles of this application are not limited to any details of these examples. Rather, based on the teachings of the disclosure of this application, these principles can be applied to many other embodiments.

[0062] In one specific implementation, Jenkins uses the application and branch as queuing credentials. Each credential is only allowed to trigger if there are no running tasks. When triggered, the artifact record closest to the last completed execution record is retrieved and executed. If the current record does not meet the triggering conditions, the scanning of records from other application iterations continues.

[0063] Furthermore, after Checkout is complete, a script dynamically cleans up unnecessary file data in the workspace of the currently running job (to avoid excessive file interference), and dynamically synchronizes the specified unit test files to the specified directory under the current running space for initialization based on the running parameters. It also dynamically specifies the target file for execution, improving running efficiency.

[0064] To improve file synchronization efficiency and reduce network overhead, the asynchronous program QOA-JOB-JAR can be deployed on the same machine as Jenkins, and the dynamic file library and Jenkins workspace directory can be placed on high IO performance storage.

[0065] In some implementations, preset analysis scenario prompts can be obtained first, and these prompts, along with a set of business code changes, can be input into a large model to output a risk assessment report containing risk level, scope of impact, and test recommendations, providing a basis for decision-making in subsequent test priority allocation and quality assessment. Figure 2 This is a flowchart illustrating a multi-system collaborative code change risk assessment method that integrates a large model, according to another exemplary embodiment. Figure 2 The flowchart 20 shown is a detailed description of the operation process of the quality R&D support module.

[0066] like Figure 2 As shown, in S202, the preset analysis scenario prompt words are obtained.

[0067] For example, preset analysis scenario prompts can be loaded from the database of the quality management platform. These prompts can include instructions for different analysis dimensions, such as "the impact of changes to the evaluation method logic on downstream modules," "the potential risks of database field changes to interface calls," and "the potential compatibility issues that configuration file adjustments may cause."

[0068] These prompts are pre-configured by system administrators or testing experts and can be dynamically adjusted for different types of applications, code structures, and business scenarios.

[0069] In S204, the preset analysis scenario prompts and the set of business code changes are input into the large model, and combined with the business knowledge base, the impact of code changes is analyzed.

[0070] The quality development support module inputs the set of business code changes and analysis scenario prompts into the large model. The analysis scenario prompts can be generated from the business knowledge base, or relevant data from the page number knowledge base can be input into the large model. Based on the input information, the large model performs semantic understanding and dependency reasoning on the changed code, analyzes the modules, interfaces, or configuration files that the changed logic may affect, and outputs the analysis results.

[0071] The analysis may include the following: a list of affected business modules, potential changes in call relationships, dependency conflict risks, possible logical anomalies, or testing blind spots.

[0072] This step enables automatic identification and classification of the impact of business changes at the code level, avoiding omissions caused by traditional assessments relying solely on human experience.

[0073] In S206, a risk assessment report is generated.

[0074] In one specific implementation, a risk assessment report can be automatically generated based on the output of the large model. The risk assessment report may include the following: a list of changed code files and their respective business modules; the risk level (e.g., high, medium, low) for each change; suggested test priorities and recommended test scope; and a risk description and recommendations generated by the large model.

[0075] The generated reports can also be automatically stored in the quality management platform database and displayed in the quality R&D platform interface in the form of charts or tables for testers and developers to refer to.

[0076] Figure 4 This is a schematic diagram illustrating a multi-system collaborative code change risk assessment system that integrates a large model, according to another exemplary embodiment. For example... Figure 4 As shown, the overall system of the application artifact code change risk assessment and individual test automatic generation system provided in this application includes the following steps: The QOA-JOB-JAR asynchronous auxiliary program retrieves completed application artifacts and their corresponding pipeline definitions and build configuration information from the external system LINGXI. More specifically, QOA-JOB-JAR can write this information into the quality management platform database (QOA-DB) according to preset data synchronization rules, generating an artifact information table. This artifact information table records key data such as application identifier, iteration version, branch name, build path, and build parameters, providing fundamental data support for subsequent change analysis.

[0077] It can also generate a set of code commit records associated with the target artifact based on the artifact information table and the "Relationship between Submission and Change Business Codes" data table maintained internally by the system. This step enables a precise mapping between artifacts and specific code commit behaviors, providing a traceable basis for subsequent change analysis. Furthermore, it allows for the rapid definition of support business code tag features through configuration to collect valid code for more scenarios.

[0078] Based on the aforementioned set of code commit records and the system's existing "Relationship between Committed and Changed Business Codes," the system merges and assembles code changes layer by layer according to the hierarchical relationships of branches, files, and methods, forming a complete and orderly set of business code changes. This process effectively integrates code differences across branches and modules, ensuring that the generated change set contains only valid code changes related to the current artifact.

[0079] Alternatively, the QOA-JOB-JAR asynchronous auxiliary program can be used. Based on preset unit test scenario prompts, the system inputs the aforementioned set of business code changes into the large model for processing. The large model automatically generates corresponding unit test code files for each change class file based on the code logic and the semantics of the prompts. The system further stores the generated unit test files in the specified branch directory and corresponding package path in shared storage, according to the directory and package path information in the "Relationship between Submitted and Changed Business Code," to maintain consistency between the file structure and the source code repository.

[0080] The QOA-JOB-JAR asynchronous auxiliary program can also be used. Based on actual needs and combined with the branch and build directory information of the referenced version, the system can trigger unit test execution tasks to the Jenkins continuous integration platform. After receiving the task, the Jenkins system automatically loads the corresponding unit test file and executes the test. At the same time, it controls the sequential execution of tasks on the same branch of the same application based on a queuing algorithm. Tasks on different applications or branches can run in parallel, thereby improving overall testing efficiency while ensuring execution stability.

[0081] A shared storage + runtime copy approach is adopted to separate the file repository of asynchronously automatically generated unit test files from the runtime workspace. A queue algorithm is used to control the independent execution of the same application and branch, while different applications and branches can run in parallel. This improves operational efficiency while ensuring a high success rate. Furthermore, since storage is on the same volume, copying is faster than network transmission; therefore, a co-location deployment of QOA-JOB-JAR and Jenkins is adopted.

[0082] Furthermore, the QOA-DEVOPS quality development support program, combined with preset analysis scenario prompts, allows users to input a set of business code changes into a large model for in-depth analysis. Based on code logic relationships and call dependencies, the large model identifies potential risk points and affected modules, ultimately outputting a risk assessment report that includes risk level, impact scope, and testing recommendations.

[0083] The proposed solution for risk assessment and automatic generation of product code changes in this application can automate the entire process from product construction information synchronization, code change identification, and unit test file generation to risk analysis and result output, forming a complete quality analysis and verification process.

[0084] This solution combines artifact basic information with application build configurations to generate a unified artifact information table, achieving a precise correspondence between application artifacts and actual code submissions. This data structure enables the system to establish stable relationships during the version build phase, providing a traceable data foundation for subsequent code change identification and unit test file generation.

[0085] During the change identification phase, the system accurately identifies business code changes belonging to the target artifact by comparing artifact information with commit records. Compared to relying on GitLab interfaces to directly obtain diff data, this solution avoids the identification difficulties caused by excessive data volume and the mixing of multiple applications. The system adopts a multi-level merging strategy of branches, directories, files, and methods, which can quickly assemble a complete and accurate set of business changes; and supports defining business tag features through configurable rules to adapt to differences in project structures and business scenarios.

[0086] During the unit test generation and execution phases, the system employs shared storage and runtime file copying to isolate automatically generated unit test files from the Jenkins workspace. Task scheduling utilizes an application-branch-based queuing algorithm, executing tasks within the same application and branch sequentially, while tasks from different applications or branches can run in parallel, thus balancing execution stability and efficiency. QOA-JOB-JAR and the Jenkins system are deployed on the same host and use the same storage volume, reducing latency caused by network transmission and improving the triggering speed and execution success rate of unit test tasks.

[0087] In terms of testing efficiency, statistics from the trial operation phase show that the Level 1 system (approximately 90 applications) can extract about 3,000 business code changes in a single iteration cycle and automatically generate corresponding unit test files. Based on the calculation that manually writing a unit test takes about 2 minutes per line, the system can save approximately 100 hours of manpower per week, significantly improving resource utilization and output efficiency during the testing phase.

[0088] The system also has the capability to analyze the impact of code changes. By combining the semantic reasoning capabilities of the business knowledge base and the large model, it can automatically identify the impact paths and potential risk points of code changes, and generate structured reports that include risk levels, scope of impact, and testing recommendations. This provides testers with quantifiable risk information and test priority references, making the analysis results more closely aligned with business logic and actual application scenarios.

[0089] Those skilled in the art will understand that all or part of the steps of the above embodiments are implemented as a computer program executed by a CPU. When the computer program is executed by the CPU, it performs the functions defined by the method provided in this application. The program can be stored in a computer-readable storage medium, such as a read-only memory, a magnetic disk, or an optical disk.

[0090] Furthermore, it should be noted that the above figures are merely illustrative representations of the processes included in the method according to exemplary embodiments of this application, and are not intended to be limiting. It is readily understood that the processes shown in the above figures do not indicate or limit the temporal order of these processes. Additionally, it is readily understood that these processes may be executed synchronously or asynchronously, for example, in multiple modules.

[0091] The following are embodiments of the apparatus described in this application, which can be used to execute the embodiments of the method described in this application. For details not disclosed in the apparatus embodiments of this application, please refer to the embodiments of the method described in this application.

[0092] Figure 5 This is a block diagram illustrating a multi-system collaborative code change risk assessment system that integrates a large model, according to an exemplary embodiment. For example... Figure 5 As shown, the multi-system collaborative code change risk assessment system 50 integrating a large model includes: a research and development process platform module 502, a quality research and development extension module 504, and a quality research and development auxiliary module 506. The multi-system collaborative code change risk assessment system 50 integrating a large model may also include: a quality management platform database 508.

[0093] The R&D process platform module 502 is used to generate application artifacts and their corresponding artifact construction configurations; the R&D process platform module 502 is also used to construct the application artifacts and generate the artifact construction configurations through the pipeline definition corresponding to the application artifacts.

[0094] The quality R&D extension module 504 is used to generate a product information table based on the application product and its corresponding pipeline construction configuration; it is also used to extract the code submission records associated with the application product, merge and assemble them layer by layer in a predetermined order to generate a business code change set, and input the business code change set into the large model based on preset unit test scenario prompts to automatically generate the corresponding unit test code; it is also used to perform unit tests on the application product based on the unit test code according to a preset operation mechanism strategy, the preset operation mechanism strategy including: queuing strategy, work area management strategy, and communication collaboration strategy.

[0095] The quality research and development expansion module 504 specifically includes: The synchronization unit is used to synchronize the application product and its corresponding production line construction configuration by the R&D process platform module; it is also used to generate the product information table according to the application product and its corresponding production line construction configuration and preset rules, and store the product information table in the quality management platform database.

[0096] The extraction unit is used to obtain the relationship table between submission and change business codes; it is also used to generate a set of associated code submission records based on the product information table and the relationship table between submission and change business codes; and it is also used to generate a set of application product business code changes based on the set of associated code submission records and the relationship table between submission and change business codes.

[0097] The large model unit is used to obtain preset unit test scenario prompts based on a queuing strategy; it is also used to input the preset unit test scenario prompts and the business code change set into the large model in an asynchronous auxiliary manner to automatically generate corresponding unit test code for each class; and it manages the workspace through a predefined script.

[0098] The test unit is used to send unit test tasks to the Jenkins system based on the unit test code in an asynchronous manner, so that the Jenkins system can perform unit tests on the application artifact; during the execution of the Jenkins system, the execution of the unit test is controlled by a queuing algorithm.

[0099] The quality R&D support module 506 is used to call the large model and combine it with the business knowledge base to perform code change impact analysis based on the business code change set, and generate a risk assessment report; the quality R&D support module 506 is also used to obtain preset analysis scenario prompt words; input the preset analysis scenario prompt words and the business code change set into the large model, thereby performing code change impact analysis and generating a risk assessment report.

[0100] The quality management platform database 508 is used to store the product information table, the application product code submission record, the business code change set, and the unit test code.

[0101] The multi-system collaborative code change risk assessment system based on the integrated large model of this application includes a development process platform module for generating application artifacts and their corresponding artifact build configurations; a quality development extension module for generating artifact information tables based on application artifacts and their corresponding pipeline build configurations; it also extracts code submission records associated with the application artifacts, merges and assembles them layer by layer in a predetermined order to generate a set of business code changes, and inputs the set of business code changes into the large model based on preset unit test scenario prompts to automatically generate corresponding unit test code; and it further includes performing unit tests on the application artifacts based on the unit test code according to a preset operating mechanism strategy, which includes queuing strategies, workspace management strategies, and communication collaboration strategies, to accurately filter actual changes to application artifacts, and, combined with the large model, more accurately generate effective unit test code, thereby improving the testing quality and iteration efficiency of application artifacts.

[0102] like Figure 6 As shown, this application embodiment provides an electronic device, including a processor 610, a memory 620 and a bus 640, wherein the processor 610 and the memory 620 communicate with each other through the bus 640; Memory 620 is used to store computer programs; When the processor 610 executes the program stored in the memory 630, it implements the multi-system collaborative code change risk assessment method of the fusion large model of any of the above embodiments.

[0103] The communication interface 620 is used for communication between the above-mentioned electronic devices and other devices.

[0104] The memory 630 may include random access memory (RAM) or non-volatile memory, such as at least one disk storage device. Optionally, the memory 630 may also be at least one storage device located remotely from the aforementioned processor 610.

[0105] If the methods described in this application are implemented as software functional units and sold or used as independent products, they can be stored in a computer-readable storage medium. Based on this understanding, all or part of the processes in the methods of the above embodiments of this application can be implemented by a computer program instructing related hardware. The computer program can be stored in a computer-readable storage medium, and when executed by a processor, it can implement the steps of the various method embodiments described above. The computer program includes computer program code, which can be in the form of source code, object code, executable files, or certain intermediate forms.

[0106] This application provides a computer-readable storage medium storing one or more programs, which can be executed by one or more processors to implement the multi-system collaborative code change risk assessment method of the fusion large model described in any of the above embodiments. For example, a development process platform module is used to generate application artifacts and their corresponding artifact build configurations; a quality development extension module is used to generate an artifact information table based on the application artifacts and their corresponding pipeline build configurations; it is also used to extract code submission records associated with the application artifacts, merge and assemble them layer by layer in a predetermined order to generate a set of business code changes, and input the set of business code changes into the large model based on preset unit test scenario prompts to automatically generate corresponding unit test code; it is also used to perform unit tests on the application artifacts based on the unit test code according to a preset operating mechanism strategy, the preset operating mechanism strategy including: queuing strategy, workspace management strategy, and communication collaboration strategy.

[0107] Exemplary embodiments of this application have been specifically shown and described above. It should be understood that this application is not limited to the detailed structures, arrangements, or implementation methods described herein; rather, this application is intended to cover various modifications and equivalent arrangements contained within the spirit and scope of the appended claims.

Claims

1. A multi-system collaborative code change risk assessment system integrating a large model, characterized in that, include: The R&D process platform module is used to generate application artifacts and their corresponding artifact construction configurations; The quality R&D extension module is used to generate a product information table based on the application product and its corresponding pipeline construction configuration; it is also used to extract the code submission records associated with the application product, merge and assemble them layer by layer in a predetermined order to generate a business code change set, and input the business code change set into the large model based on preset unit test scenario prompt words to automatically generate the corresponding unit test code. It is also used to perform unit testing of the application artifact based on the unit test code according to a preset operation mechanism strategy, wherein the preset operation mechanism strategy includes: queuing strategy, work area management strategy, and communication collaboration strategy; The quality R&D support module is used to perform impact analysis of code changes based on the set of business code changes by calling a large model and combining it with a business knowledge base, and to generate a risk assessment report.

2. The system as described in claim 1, characterized in that, Also includes: The quality management platform database is used to store the product information table, the application product code submission records, the business code change set, and the unit test code.

3. The system as described in claim 1, characterized in that, The R&D process platform module is also used to build the application artifact and generate the artifact building configuration through the pipeline definition corresponding to the application artifact.

4. The system as described in claim 1, characterized in that, The quality R&D expansion module includes: The synchronization unit is used to synchronize the application product and its corresponding production line construction configuration by the R&D process platform module; it is also used to generate the product information table according to the application product and its corresponding production line construction configuration and preset rules, and store the product information table in the quality management platform database.

5. The system as described in claim 1, characterized in that, The quality R&D expansion module includes: The extraction unit is used to obtain the relationship table between submission and change business codes; it is also used to generate a set of associated code submission records based on the product information table and the relationship table between submission and change business codes; and it is also used to merge and assemble the set of associated code submission records and the relationship table between submission and change business codes in a predetermined order to generate a set of change business codes.

6. The system as described in claim 5, characterized in that, Based on the set of associated code submission records and the table of submission and change business code relationships, the business code change set is obtained by merging them layer by layer according to branches, files, and methods.

7. The system as described in claim 1, characterized in that, The quality R&D expansion module includes: The large model unit is used to obtain preset unit test scenario prompts based on a queuing strategy; it is also used to input the preset unit test scenario prompts and the business code change set into the large model in an asynchronous auxiliary manner to automatically generate corresponding unit test code for each class; and it manages the workspace through a predefined script.

8. The system as described in claim 1, characterized in that, The quality R&D expansion module includes: The test unit is used to send unit test tasks to the Jenkins system based on the unit test code in an asynchronous manner, so that the Jenkins system can perform unit tests on the application artifact; during the execution of the Jenkins system, the execution of the unit test is controlled by a queuing algorithm.

9. The system as described in claim 1, characterized in that, The quality R&D support module is also used to obtain preset analysis scenario prompts; input the preset analysis scenario prompts and the set of business code changes into the large model, combine them with the business knowledge base to conduct code change impact analysis, and generate a risk assessment report.

10. A multi-system collaborative code change risk assessment method integrating a large model, characterized in that, include: Obtain the application artifact and its corresponding artifact build configuration; Generate a product information table based on the application products and their corresponding production line configuration; Extract the code submission records associated with the application artifact, and merge and assemble them layer by layer in a predetermined order to generate a set of business code changes; The set of business code changes is input into the large model based on preset unit test scenario prompts to automatically generate corresponding unit test code; Based on the unit test code, the application artifact is unit tested according to a preset operation mechanism strategy, which includes: queuing strategy, workspace management strategy, and communication collaboration strategy. Based on the aforementioned set of business code changes, a large model is invoked in conjunction with a business knowledge base to conduct an impact analysis of the code changes and generate a risk assessment report.

Images