Isolating Highly Coupled Software Components
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Validating software components is complex and costly, especially in legacy code, where isolating and testing individual components without altering the production code is challenging due to the exponential growth of complexity and the need for fake data and resources like dates, database connections, and email services.
Innovation Solution
The method involves inserting hooking code into the production code base using a weaver to manage mock objects and fake data through a mock framework, allowing for isolation and validation of software components without changing the production design, utilizing configuration files and metadata manipulation to redirect method calls to fake or real objects dynamically.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If software components are isolated using traditional methods (wrapping system calls, creating fake objects), then testing coverage can be improved, but device complexity and difficulty of implementation increase exponentially
Solution Approach 1:
The patent introduces an intermediary layer (the isolation mechanism) that sits between the test code and the production code base. This intermediary automatically manages the creation and injection of fake objects, handling dependencies without requiring manual wrapping of system calls or complex configuration. The intermediary translates high-level isolation requests into low-level object substitutions, thereby improving testing coverage while keeping the implementation approach simple and unified.
2Ease of operation
If production code is modified to support isolation (using patterns like Dependency Injection or Abstract Factory), then components can be tested in isolation, but the production code design must be changed which is not always possible or desired
Solution Approach 1:
Instead of modifying the production code to support isolation (the conventional approach), the patent inverts the approach by making the isolation mechanism independent of production code changes. The system automatically analyzes the production code base, identifies components to be isolated, and injects appropriate fake objects without requiring the production code to implement patterns like Dependency Injection or Abstract Factory. This inversion allows isolation capability while preserving the original production code design.
3Reliability
If fake objects are used to isolate components, then testing can proceed without altering production code, but managing complex dependencies and multiple fake objects requires complex mechanisms and configuration files
Solution Approach 1:
The patent merges multiple isolated components and their dependencies into a unified isolation context. Instead of managing each fake object separately with individual configuration files and complex mechanisms, the system combines all isolation requirements into a single coordinated framework. This unified approach automatically handles the creation, injection, and coordination of multiple fake objects across different components, reducing mechanism complexity while maintaining comprehensive testing capability.
Data Source
AI summary
A software testing system operative to test a software application comprising a plurality of software components, at least some of which are highly coupled hence unable to support a dependency injection, each software component operative to perform a function, the system comprising apparatus for at least partially isolating, from within the software application, at least one highly coupled software component which performs a given function, and apparatus for testing at least the at least partially isolated highly coupled software component.


