Source Code Change Resolver for CI Cycle Optimization
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Continuous Integration (CI) cycles are prolonged due to the performance of irrelevant tests on code sections that do not require them, especially with the rise of Continuous Delivery, where code changes are immediately available to customers, leading to increased processor and resource utilization during source code testing.
Innovation Solution
An intelligent engine that listens to Source Code Management (SCM) changes, analyzes the changes, and executes customized rules based on classifications, such as user, geographic, time, and file-type metadata, to determine the necessity and extent of testing, thereby reducing irrelevant tests and optimizing resource utilization.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If the same list of pre-selected tests is used to test every portion of code changed, then quality control is maintained, but CI cycles are prolonged due to irrelevant tests being performed
Solution Approach 1:
The patent segments the monolithic test suite into multiple categorized test sets (unit tests, integration tests, system tests, security tests, performance tests). The intelligent engine selectively executes only the relevant test categories based on the type of code change detected, rather than running all tests uniformly. This segmentation allows quality control to be maintained through comprehensive testing when needed while significantly reducing CI cycle time by avoiding irrelevant tests.
Solution Approach 2:
The patent implements partial action by executing only the necessary subset of tests based on the change classification. The intelligent engine determines the minimal required testing scope by analyzing the code change type and selecting corresponding test categories from the predefined sets. This partial execution approach maintains sufficient quality control while eliminating waste from running excessive irrelevant tests, directly resolving the contradiction between reliability and productivity.
2Reliability
If pre-selected tests are executed on every code change, then comprehensive quality assurance is achieved, but processor and resource utilization increase due to irrelevant testing
Solution Approach 1:
The patent applies local quality by tailoring the testing intensity and scope to the specific characteristics of each code change. The intelligent engine classifies changes (e.g., new file, modified file, deleted file, security-related, performance-related) and selects test categories that are locally appropriate for that change type. This ensures comprehensive quality assurance for relevant code sections while minimizing processor and resource utilization by avoiding testing of unrelated code portions.
3Reliability
If all pre-selected tests are run on every code change, then thorough validation is performed, but the time needed for Continuous Delivery increases
Solution Approach 1:
The patent implements preliminary action by pre-categorizing test suites into multiple types (unit, integration, system, security, performance tests) and establishing classification rules before code changes occur. The intelligent engine uses these pre-established categories and rules to quickly determine the appropriate test subset for each change, enabling thorough validation of relevant code while minimizing Continuous Delivery time by avoiding unnecessary tests from the outset.
Data Source
AI summary
In an example embodiment, a method of resolving source code changes is provided. It is determined whether there are any portions of source code dependent on a changed portion of source code. Then, for each portion of source code including the changed portion of source code and portions of source code dependent on the changed portion of source code, one or more pieces of metadata for the portion of source code are obtained, a danger score for the portion of source code is calculated based on the one or more pieces of metadata, an execution rule corresponding to the danger score is retrieved, and the execution rule is executed, causing a command to be executed on an external run-time component.