FractalDataWorks.CodeBuilder.Analysis 0.6.0-rc.1

FractalDataWorks.CodeBuilder.Analysis

Abstractions for code analysis expectations used in testing source generators and code generation output.

Overview

This package defines interfaces for a fluent expectation API that verifies generated code structure. It provides contracts for asserting the presence and characteristics of namespaces, classes, interfaces, records, enums, methods, properties, fields, and constructors within syntax trees.

Installation

<PackageReference Include="FractalDataWorks.CodeBuilder.Analysis" Version="1.0.0" />

Core Interfaces

Entry Point

From ISyntaxExpectations.cs:6-21:

public interface ISyntaxExpectations
{
    /// <summary>
    /// Creates expectations for generated code.
    /// </summary>
    /// <param name="generatedCode">The generated code as a string.</param>
    /// <returns>A syntax tree expectations instance.</returns>
    ISyntaxTreeExpectations ExpectCode(string generatedCode);

    /// <summary>
    /// Creates expectations for a syntax tree.
    /// </summary>
    /// <param name="syntaxTree">The syntax tree object.</param>
    /// <returns>A syntax tree expectations instance.</returns>
    ISyntaxTreeExpectations ExpectSyntaxTree(object syntaxTree);
}

Syntax Tree Expectations

From ISyntaxTreeExpectations.cs:8-55:

public interface ISyntaxTreeExpectations
{
    ISyntaxTreeExpectations HasNamespace(string namespaceName, Action<INamespaceExpectations>? expectations = null);
    ISyntaxTreeExpectations HasClass(string className, Action<IClassExpectations>? expectations = null);
    ISyntaxTreeExpectations HasInterface(string interfaceName, Action<IInterfaceExpectations>? expectations = null);
    ISyntaxTreeExpectations HasEnum(string enumName, Action<IEnumExpectations>? expectations = null);
    ISyntaxTreeExpectations HasRecord(string recordName, Action<IRecordExpectations>? expectations = null);
    ISyntaxTreeExpectations Compiles();
}

Class Expectations

From IClassExpectations.cs:8-85:

public interface IClassExpectations
{
    IClassExpectations HasAccessModifier(string modifier);
    IClassExpectations HasMethod(string methodName, Action<IMethodExpectations>? expectations = null);
    IClassExpectations HasProperty(string propertyName, Action<IPropertyExpectations>? expectations = null);
    IClassExpectations HasField(string fieldName, Action<IFieldExpectations>? expectations = null);
    IClassExpectations HasConstructor(Action<IConstructorExpectations>? expectations = null);
    IClassExpectations ImplementsInterface(string interfaceName);
    IClassExpectations InheritsFrom(string baseClassName);
    IClassExpectations IsAbstract();
    IClassExpectations IsSealed();
    IClassExpectations IsStatic();
    IClassExpectations IsPartial();
}

Method Expectations

From IMethodExpectations.cs:6-54:

public interface IMethodExpectations
{
    IMethodExpectations HasReturnType(string returnType);
    IMethodExpectations HasParameter(string parameterName, string parameterType);
    IMethodExpectations IsAsync();
    IMethodExpectations IsStatic();
    IMethodExpectations IsVirtual();
    IMethodExpectations IsOverride();
    IMethodExpectations IsAbstract();
}

Property Expectations

From IPropertyExpectations.cs:6-44:

public interface IPropertyExpectations
{
    IPropertyExpectations HasType(string propertyType);
    IPropertyExpectations HasGetter();
    IPropertyExpectations HasSetter();
    IPropertyExpectations HasInitSetter();
    IPropertyExpectations IsReadOnly();
    IPropertyExpectations IsStatic();
}

Field Expectations

From IFieldExpectations.cs:6-32:

public interface IFieldExpectations
{
    IFieldExpectations HasType(string fieldType);
    IFieldExpectations IsReadOnly();
    IFieldExpectations IsStatic();
    IFieldExpectations IsConst();
}

Constructor Expectations

From IConstructorExpectations.cs:6-21:

public interface IConstructorExpectations
{
    IConstructorExpectations HasParameter(string parameterName, string parameterType);
    IConstructorExpectations IsStatic();
}

Enum Expectations

From IEnumExpectations.cs:6-22:

public interface IEnumExpectations
{
    IEnumExpectations HasValue(string valueName, int? value = null);
    IEnumExpectations HasUnderlyingType(string underlyingType);
}

Architecture

This package provides interface definitions only. For concrete implementations, see:

• FractalDataWorks.CodeBuilder.Analysis.CSharp - Roslyn-based implementation for C# code verification

The separation allows language-agnostic test contracts while supporting language-specific implementations.

Related Packages

Best Practices

1. Use the fluent API - Chain expectations for readable test code
2. Test generated code structure - Verify classes, methods, and properties exist with correct signatures
3. Verify compilation - Use Compiles() to ensure generated code is valid C#
4. Test modifiers - Verify access modifiers, sealed/abstract, and other declarations

Next Steps

• See FractalDataWorks.CodeBuilder.Analysis.CSharp for the concrete implementation
• See test projects for usage examples