How It Works

Logic Assurance generates test suites with a fleet of specialist generators, one per logic type, coordinated by an orchestrator that routes each artifact to the right generator. Before a generator writes any test, it pulls in the Dataverse metadata the artifact depends on, so the tests it produces use your real schema. Suites are persisted per artifact and streamed to the browser as they complete.

The generation pipeline

Test Generation Pipeline

Select testable artifacts

Orchestrator routes each artifact by its logic type

Generator pre-fetches Dataverse metadata (via MCP)

the entities and fields the artifact touches

Generator produces a grounded test suite

Suite persisted per artifact

artifact-ready streamed to the browser (SSE)

1. Browse and select. You browse the project's testable artifacts, each tagged with its logic type and current coverage, and select the ones to generate for.
2. Start. The API returns a jobId and runs the work in the background.
3. Route. The orchestrator inspects each selected artifact and routes it to the specialist generator for its logic type.
4. Ground. Each generator scans its artifact for the entities and fields it references, then fetches those entities' metadata from Dataverse through the MCP server.
5. Generate. The generator produces a test suite with the entity schema in hand, so inputs and expected saves use real field names and types.
6. Persist and stream. The suite is saved for that artifact, and an artifact-ready event streams to the browser as each one completes.

Architecture

The orchestrator inspects each artifact and routes it to the generator for its logic type. Every generator first pre-fetches the Dataverse metadata the artifact depends on, then produces a grounded suite.

Logic Assurance Generator Fleetrouted by logic type · metadata-grounded

Orchestrator

inspects each artifact and routes it to the generator for its logic type

6 Specialist Generators · run in parallel

FormulaDecision TableDecision TreeValidationValidation SetLogic Flow

Pre-fetch Dataverse metadata

the real schema the artifact touches, injected into generation

Grounded suite

structured test cases, persisted per artifact

The generator fleet

An orchestrator routes each artifact to the generator that understands its logic type. Generators run in parallel.

Generator	Handles	Logic type
FormulaTestGenerator	Calculated-value formulas	Formula
DecisionTableTestGenerator	Decision-table logic blocks	DecisionTable
DecisionTreeTestGenerator	Decision-tree logic blocks	DecisionTree
ValidationTestGenerator	Single validations	Validation
ValidationSetTestGenerator	Grouped validation sets	ValidationSet
LogicFlowTestGenerator	Process and logic flows	flow

Each generator understands what a meaningful test looks like for its type: a validation's true and false outcomes, a decision table's branches, a flow's outputs and side effects. That specialization is why the generated cases are relevant rather than generic.

Metadata grounding

The difference between a useful test and a plausible-looking one is whether it matches your data. Before generating, each specialist:

1. Scans the artifact for the entities and fields it references.
2. Fetches those entities' metadata from Dataverse, respecting a configurable cap on how many entities to pull and excluding platform prefixes such as flwn_ and def_.
3. Injects that schema into the generation prompt.

The result is test data built on your real field names and types, not on guesses. A test's expected saves name the actual entity and columns that the logic writes, which is what makes the suites suitable for real execution rather than illustration.

Read-only and safe

Logic Assurance reads your logic and the Dataverse schema through the MCP server, and writes the generated suites to its own store. It never modifies the project or the data. You can point it at production to generate a baseline of coverage without any risk to the environment.