Isolating Highly Coupled Software Components

Resolve Bottlenecks,
Find Innovative Solutions
Generate 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

VSEngineering 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

Engineering Contradiction:
Improvetesting coverageVSAvoidimplementation complexity
Core Design Contradiction:
ReliabilityVSDevice complexity

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.

Inventive Principle:
Principle #24Intermediary (Mediator)

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

Engineering Contradiction:
Improvecomponent isolation capabilityVSAvoidcode modification requirement
Core Design Contradiction:
Ease of operationVSEase of manufacture

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.

Inventive Principle:
Principle #13The other way round (Inversion)

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

Engineering Contradiction:
Improvetesting capabilityVSAvoidmechanism complexity
Core Design Contradiction:
ReliabilityVSDevice complexity

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.

Inventive Principle:
Principle #5Merging (Combining)

Data Source

PatentUS10078574B2Methods and systems for isolating software components
Publication Date: 2018.09.18 TYPEMOCK
  • US10078574B2 patent drawing
  • US10078574B2 patent drawing
  • US10078574B2 patent drawing

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.