SFBLITesterTools 1.2.1

SFBLITesterTools

A powerful .NET 8 library that simplifies unit testing by automatically creating test objects with realistic dummy data. Use reflection and fluent configuration to generate complex object graphs while maintaining full control over specific property values.

🚀 Quick Start

using SFBLITesterTools.Tools;

// Create a test object with dummy data
var customer = TesterHelper.For<Customer>().Create();

// Create with specific property values
var customCustomer = TesterHelper.For<Customer>()
    .With(c => c.Name, "John Doe")
    .With(c => c.Email, "john@example.com")
    .WithNull(c => c.Address)  // Explicitly set to null
    .Create();

✨ Key Features

• 🎯 Type-safe property configuration using lambda expressions
• 🔧 Automatic dummy data generation for all .NET primitive types
• 🏗️ Complex object graph creation with nested objects and collections
• 🔒 Private constructor support - creates instances even with private/internal constructors
• 🆕 Init-only property support - full C# 9+ init property compatibility
• 🔐 Private property access via reflection and backing field manipulation
• ♻️ Circular reference protection with configurable depth limits
• 📋 Collection handling (Lists, Arrays, Dictionaries)
• 🎛️ Explicit null control to distinguish between "not set" and "explicitly null"
• ✅ Nullable reference type support with proper compiler satisfaction

📖 Usage Examples

Basic Object Creation

public class Product
{
    public string Name { get; set; }
    public decimal Price { get; set; }
    public bool IsActive { get; set; }
    public DateTime CreatedDate { get; set; }
}

// Simple creation with all dummy values
var product = TesterHelper.For<Product>().Create();
// Result: Name="DummyString", Price=42, IsActive=true, CreatedDate=2024-01-01

Property Customization

public class Order
{
    public string OrderId { get; set; }
    public DateTime OrderDate { get; set; }
    public decimal Total { get; set; }
    public Customer Customer { get; set; }
    public List<OrderItem> Items { get; set; }
}

var customOrder = TesterHelper.For<Order>()
    .With(o => o.OrderId, "ORD-12345")
    .With(o => o.OrderDate, DateTime.Now)
    .With(o => o.Total, 299.99m)
    .Create();
// Customer and Items will be automatically populated with dummy data

Null Handling

public class User
{
    public string Username { get; set; }
    public string? Email { get; set; }        // Nullable
    public Profile? Profile { get; set; }     // Nullable object
}

var userWithNulls = TesterHelper.For<User>()
    .With(u => u.Username, "testuser")
    .WithNull(u => u.Email)     // Explicitly null
    .WithNull(u => u.Profile)   // Explicitly null
    .Create();

Init-Only Properties (C# 9+)

public record PersonRecord
{
    public string FirstName { get; init; } = string.Empty;
    public string LastName { get; init; } = string.Empty;
    public int Age { get; init; }
    public DateTime BirthDate { get; init; }
}

var person = TesterHelper.For<PersonRecord>()
    .With(p => p.FirstName, "Jane")
    .With(p => p.Age, 25)
    .Create();
// LastName and BirthDate get dummy values, init properties work perfectly

Private Constructor Support

public class Singleton
{
    public string Name { get; set; }
    public int Value { get; set; }
    
    private Singleton() { }  // Private constructor
    
    public static Singleton Instance { get; } = new();
}

// Works automatically - finds and uses private constructor
var testSingleton = TesterHelper.For<Singleton>()
    .With(s => s.Name, "Test Instance")
    .Create();

Nested Objects and Collections

public class Company
{
    public string Name { get; set; }
    public Address HeadOffice { get; set; }
    public List<Employee> Employees { get; set; }
    public Dictionary<string, string> Metadata { get; set; }
}

public class Employee
{
    public string Name { get; set; }
    public string Department { get; set; }
    public decimal Salary { get; set; }
}

var company = TesterHelper.For<Company>()
    .With(c => c.Name, "Acme Corp")
    .WithMaxDepth(3)  // Control nesting depth
    .Create();

// Result:
// - HeadOffice will be a populated Address object
// - Employees will contain Employee objects with dummy data
// - Metadata will contain at least one key-value pair

Depth Control

public class BlogPost
{
    public string Title { get; set; }
    public Author Author { get; set; }
    public List<Comment> Comments { get; set; }
}

public class Comment
{
    public string Text { get; set; }
    public Author Author { get; set; }  // Could cause deep nesting
}

var blogPost = TesterHelper.For<BlogPost>()
    .WithMaxDepth(2)  // Prevent excessive nesting
    .Create();

🔧 Default Dummy Values

🎯 API Reference

Core Methods

Usage Patterns

// Minimal setup
var obj = TesterHelper.For<MyClass>().Create();

// Full configuration
var obj = TesterHelper.For<MyClass>()
    .With(x => x.Property1, "custom value")
    .With(x => x.Property2, 100)
    .WithNull(x => x.NullableProperty)
    .WithMaxDepth(2)
    .Create();

📦 Installation

NuGet Package

dotnet add package SFBLITesterTools

Package Manager Console

Install-Package SFBLITesterTools

Project Reference

<ItemGroup>
  <ProjectReference Include="path\to\SFBLITesterTools.csproj" />
</ItemGroup>

🧪 Testing Scenarios

Unit Test Example

[Test]
public void CalculateOrderTotal_ShouldSumItemPrices()
{
    // Arrange
    var order = TesterHelper.For<Order>()
        .With(o => o.Items, new List<OrderItem>
        {
            TesterHelper.For<OrderItem>().With(i => i.Price, 10.00m).Create(),
            TesterHelper.For<OrderItem>().With(i => i.Price, 15.00m).Create()
        })
        .Create();

    var calculator = new OrderCalculator();

    // Act
    var total = calculator.CalculateTotal(order);

    // Assert
    Assert.AreEqual(25.00m, total);
}

Testing Null Scenarios

[Test]
public void ProcessUser_WithNullEmail_ShouldHandleGracefully()
{
    // Arrange
    var user = TesterHelper.For<User>()
        .With(u => u.Name, "Test User")
        .WithNull(u => u.Email)  // Explicitly null
        .Create();

    var processor = new UserProcessor();

    // Act & Assert
    Assert.DoesNotThrow(() => processor.Process(user));
}

⚠️ Limitations

• Readonly fields cannot be modified after construction
• Static properties are not supported
• Abstract classes cannot be instantiated directly
• Complex generic constraints may require manual handling
• Performance overhead from reflection (test-only usage recommended)

🎯 Best Practices

1. Use only in test projects - not intended for production code
2. Set reasonable depth limits for complex object graphs
3. Override critical properties explicitly rather than relying on defaults
4. Use WithNull() explicitly when testing null-handling scenarios
5. Combine with test data builders for complex test scenarios
6. Leverage init properties for immutable test objects

🔄 Version History

• v1.2.1 - Fixed nullable reference type support in WithNull() method
• v1.1.0 - Added init-only property support
• v1.0.0 - Initial release with core functionality

📄 License

MIT License - see LICENSE file for details

🤝 Contributing

1. Fork the repository
2. Create a feature branch
3. Add comprehensive tests
4. Submit a pull request

Built for .NET 8 | Designed for Unit Testing | Powered by Reflection