mPAS Infrastructure TestCommon

https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0
Admin
A .NET testing infrastructure library providing a foundation for unit and integration tests with...
Tokens:43,436
Snippets:225
Trust Score:10
Update:11 months ago
Show doc for...
Tokens:
Raw
### C# Basic Test Example

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/revisions_short_path=6aea449

A simple C# unit test example using Mock and Assert to verify basic object creation and collection counts.

```csharp
// Usage in tests
[Fact]
public void CustomTestExample()
{
 var mock = Mock<IRepository>();
 var data = Create<Product>();
 var dataList = CreateMany<Product>(5);

 Assert.NotNull(data);
 Assert.Equal(5, dataList.Count());
}
}
```

--------------------------------

### C# Basic Unit Test Example

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/74166199921f4bcac96ae0f70f5a8a1f46766f3d

A basic example of a unit test class inheriting from TestSpecBase, demonstrating automatic mocking and instantiation of the System Under Test (Sut).

```C#
public class MyServiceTests : TestSpecBase&lt;MyService&gt;
{
    public MyServiceTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper) { }
    
    [Fact]
    public void MyTest()
    {
        // Sut is MyService with all dependencies mocked automatically
        var result = Sut.DoSomething();
        Assert.NotNull(result);
    }
}
```

--------------------------------

### Example: Product Repository Test with Seeded DbContext

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/revisions

Demonstrates a unit test for a Product Repository using an in-memory DbContext created by GetFakeDb. The example includes setting up the DbContext with initial data and testing a method to retrieve all products.

```csharp
public class MyDbContext : DbContext
{
  public MyDbContext(DbContextOptions<MyDbContext> options) : base(options) { }
  public DbSet<Product> Products { get; set; } = null!;
  public DbSet<Order> Orders { get; set; } = null!;
}

public class ProductRepositoryTests : TestSpecBase<ProductRepository>
{
  private readonly MyDbContext _context;

  public ProductRepositoryTests(ITestOutputHelper testOutputHelper)
  : base(testOutputHelper)
  {
  _context = this.GetFakeDb(
  databaseName: "TestDb-" + Guid.NewGuid(),
  dbContextFactory: options => new MyDbContext(options),
  seedFunc: (fixture, db) =>
  {
  // Seed test data
  var products = fixture.CreateMany<Product>(5).ToList();
  db.Products.AddRange(products);
  db.SaveChanges();
  });
  }

  [Fact]
  public async Task GetProduct_ExistingId_ReturnsProduct()
  {
  // Arrange
  var testProduct = Create<Product>();
  _context.Products.Add(testProduct);
  await _context.SaveChangesAsync();

  // Act
  var result = await Sut.GetByIdAsync(testProduct.Id);

  // Assert
  Assert.NotNull(result);
  Assert.Equal(testProduct.Id, result.Id);
  Assert.Equal(testProduct.Name, result.Name);
  }

  [Fact]
  public async Task GetProducts_MultipleProducts_ReturnsAll()
  {
  // Arrange
  var products = CreateMany<Product>(10).ToList();
  _context.Products.AddRange(products);
  await _context.SaveChangesAsync();

  // Act
  var results = await Sut.GetAllAsync();

  // Assert
  Assert.Equal(15, results.Count); // 5 from seed + 10 added
  }
}

```

--------------------------------

### Complete HttpContent Deserialization Example in C#

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/revisions_short_path=6aea449

Full example demonstrating how to use the Deserialize extension method on HttpContent. Shows deserialization of JSON content to a list of User objects with property validation.

```csharp
public class ApiClientTests : TestSpecBase<ApiClient>
{
    private readonly HttpClient _httpClient;

    public ApiClientTests(ITestOutputHelper testOutputHelper)
        : base(testOutputHelper)
    {
        _httpClient = Mock<HttpClient>();
    }

    [Fact]
    public async Task GetUsers_Success_DeserializesResponse()
    {
        // Arrange
        var jsonContent = new StringContent(
            @"[{\""name\"":\""John Doe\"",\""age\"":30},{\""name\"":\""Jane Smith\"",\""age\"":25}]",
            System.Text.Encoding.UTF8,
            "application/json");

        // Act
        var users = await jsonContent.Deserialize<List<User>>();

        // Assert
        Assert.NotNull(users);
        Assert.Equal(2, users.Count);
        Assert.Equal("John Doe", users[0].Name);
        Assert.Equal(30, users[0].Age);
    }
}
```

--------------------------------

### Implement IFixtureExt Interface

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/revisions_source=1

Provides an example of implementing the IFixtureExt interface for custom test extensions. This example includes mocking, creating, and freezing objects using AutoFixture.

```C#
public class CustomTestBase<T> : IFixtureExt where T : class
{
 private readonly FixtureExt _fixtureExt;

 public CustomTestBase()
 {
 _fixtureExt = new FixtureExt();
 }

 public IFixture Fixture => _fixtureExt.Fixture;

 public TMock Mock<TMock>(bool freezeIt = true) => _fixtureExt.Mock<TMock>(freezeIt);

 public TMock Create<TMock>() => _fixtureExt.Create<TMock>();

 public IEnumerable<TMock> CreateMany<TMock>() => _fixtureExt.CreateMany<TMock>();

 public IEnumerable<TMock> CreateMany<TMock>(int count) => _fixtureExt.CreateMany<TMock>(count);

 public TMock Freeze<TMock>() => _fixtureExt.Freeze<TMock>();

 // Usage in tests
[Fact]
public void CustomTestExample()
{
 var mock = Mock<IRepository>();
 var data = Create<Product>();
 var dataList = CreateMany<Product>(5);

 Assert.NotNull(data);
 Assert.Equal(5, dataList.Count());
 }
```

--------------------------------

### Unit Test with Mocked Dependencies

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/revisions

A base pattern for creating unit tests with mocked dependencies using a test specification base class. Demonstrates setup, mocking, and verification of service behavior.

```csharp
public class MyServiceTests : TestSpecBase<MyService>
{
private readonly IRepository _repository;
  
public MyServiceTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper)
{
_repository = Mock<IRepository>();
}
  
[Fact]
public async Task Method_Scenario_ExpectedResult()
{
// Arrange
var testData = Create<MyEntity>();
_repository.GetAsync(Arg.Any<int>()).Returns(testData);
  
// Act
var result = await Sut.ProcessAsync(123);
  
// Assert
Assert.Equal(testData.Value, result.Value);
await _repository.Received(1).GetAsync(123);
}
}
```

--------------------------------

### Entity Framework DbContext Setup with AutoFixture

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/revisions_source=1

Demonstrates creating and configuring an in-memory DbContext using AutoFixture for testing purposes. This snippet uses a custom factory and enables seeding data for the DbContext.

```C#
db.Products.AddRange(products);
db.SaveChanges();

// DbContext is now injected into fixture
var repository = fixture.Create<ProductRepository>();

// Act
var results = repository.GetAll();

// Assert
Assert.Equal(5, results.Count);
```

--------------------------------

### C# gRPC Testing Extensions

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/revisions_source=1

This C# example illustrates testing gRPC services using AutoFixture and Moq. It shows how to mock a gRPC service method to return a specific response and then use the mocked service within a system under test.

```csharp
[Theory, DefaultAutoData]
public async Task GrpcTest([Frozen] IMyGrpcService grpcService, MyService sut)
{
  var response = Create<MyGrpcResponse>();
  grpcService.GetDataAsync(Arg.Any<MyRequest>(), null, null, CancellationToken.None)
  .Returns(response.ToAsyncUnaryCall());

  var result = await sut.ProcessData();
  Assert.NotNull(result);
}
```

--------------------------------

### Example: Test Without TestSpecBase using Static GetFakeDb

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/revisions

Illustrates how to create an in-memory DbContext using the static GetFakeDb method, which does not require inheriting from TestSpecBase. This example shows manual instantiation of AutoFixture and seeding the context.

```csharp
[Fact]
public void TestWithoutTestSpecBase()
{
  // Arrange
  var fixture = new FixtureExt();
  var context = EFFakeExtention.GetFakeDb<MyDbContext>(
  databaseName: "TestDb",
  fixtureExt: fixture,
  seedFunc: (f, db) =>
  {
  var products = f!.CreateMany<Product>(3).ToList();
  db.Products.AddRange(products);
  db.SaveChanges();
  });

  var repository = new ProductRepository(context);

  // Act
  var result = repository.GetAll();

  // Assert
  Assert.Equal(3, result.Count);
}

```

--------------------------------

### Create Standard Test Class in C#

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/revisions_short_path=6aea449

Template for creating a standard test class that inherits from TestSpecBase<T>. This ensures consistency across tests and proper integration with the testing framework. The template includes necessary usings and constructor setup.

```csharp
using mPAS.Infrastructure.TestCommon; // Required
using Xunit;
using Xunit.Abstractions;

public class MyServiceTests : TestSpecBase<MyService> // ← ALWAYS inherit
{
    public MyServiceTests(ITestOutputHelper testOutputHelper) 
        : base(testOutputHelper) // ← ALWAYS call base
    {
    }

    [Fact]
    public void Test_Scenario_Expected()
    {
        // Arrange - use Fixture, Mock<T>(), Create<T>()
        // Act
        // Assert
    }
}
```

--------------------------------

### Unit Test Pattern in C#

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/index

This C# code demonstrates the basic structure of a unit test using TestSpecBase<T>. The System Under Test (Sut) is automatically instantiated with mocked dependencies, simplifying test setup.

```csharp
public class MyServiceTests : TestSpecBase<MyService>
{
    public MyServiceTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper) { }
    
    [Fact]
    public void MyTest()
    {
        // Sut is MyService with all dependencies mocked automatically
        var result = Sut.DoSomething();
        Assert.NotNull(result);
    }
}
```

--------------------------------

### Unit Test with Mocked Dependencies using TestSpecBase

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/revisions_short_path=6aea449

Provides an example of a unit test using a base class `TestSpecBase` that facilitates mocking dependencies with AutoMoq. The test arranges mock behavior, acts by calling the system under test, and asserts the outcome and interactions with the mocked dependency.

```csharp
public class MyServiceTests : TestSpecBase<MyService>
{
    private readonly IRepository _repository;
    
    public MyServiceTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper)
    {
        _repository = Mock<IRepository>();
    }
    
    [Fact]
    public async Task Method_Scenario_ExpectedResult()
    {
        // Arrange
        var testData = Create<MyEntity>();
        _repository.GetAsync(Arg.Any<int>()).Returns(testData);
        
        // Act
        var result = await Sut.ProcessAsync(123);
        
        // Assert
        Assert.Equal(testData.Value, result.Value);
        await _repository.Received(1).GetAsync(123);
    }
}
```

--------------------------------

### gRPC Service Testing with Mocks

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/revisions

Example of testing gRPC services by mocking the service client and using AutoFixture for test data generation. Uses NSubstitute for mocking asynchronous gRPC calls.

```csharp
[Theory, DefaultAutoData]
public async Task GrpcTest([Frozen] IMyGrpcService grpcService, MyService sut)
{
var response = Create<MyGrpcResponse>();
grpcService.GetDataAsync(Arg.Any<MyRequest>(), null, null, CancellationToken.None)
.Returns(response.ToAsyncUnaryCall());
  
var result = await sut.ProcessData();
Assert.NotNull(result);
}
```

--------------------------------

### Debugging Unit Tests with Output and Mock Verification in C#

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/revisions

Provides a C# unit test example demonstrating how to use `TestOutputHelper` for logging generated test data and mock call counts. This is essential for troubleshooting test failures by inspecting the state of generated data and the interactions with mocked dependencies.

```csharp
using Microsoft.Extensions.DependencyInjection;
using System.Text.Json;
using Xunit;
using Xunit.Abstractions;
using NSubstitute;

public class DebuggingTests
{
    public interface IService { void DoSomething(); }
    public class MyData { public string Name { get; set; } } // Example data class

    private readonly ITestOutputHelper _testOutputHelper;

    // Constructor to receive ITestOutputHelper
    public DebuggingTests(ITestOutputHelper testOutputHelper)
    {
        _testOutputHelper = testOutputHelper;
    }

    // Assuming Create<T> is available from a base class or utility
    protected T Create<T>() { /* Implementation to create test data */ return default(T); }
    protected T Mock<T>() where T : class { return Substitute.For<T>(); }

    [Fact]
    public void DebugTest_WithOutputAndMockVerification()
    {
        // Arrange
        var testData = Create<MyData>();
        testData.Name = "Sample Data"; // Set some properties

        var mockService = Mock<IService>();

        // Output generated data for debugging
        _testOutputHelper.WriteLine($"Generated Data: {JsonSerializer.Serialize(testData)}");

        // Act
        // ... your test code that uses testData and interacts with mockService ...
        // Example: 
        // mockService.DoSomething(); 

        // Assert
        // Verify mock calls and output information
        // Example: 
        // mockService.Received(1).DoSomething();
        _testOutputHelper.WriteLine($"Mock calls count: {mockService.ReceivedCalls().Count()}");

        // Additional assertions for your test logic would go here...
    }

    // Placeholder for AutoFixture or similar if not using a base class
    // public class DefaultAutoDataAttribute : AutoDataAttribute { ... }
}
```

--------------------------------

### C# Standard Test Class Template with TestSpecBase

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/index

Illustrates the standard template for creating unit test classes in C#, inheriting from `TestSpecBase<T>` and calling the base constructor with `ITestOutputHelper`. This ensures proper setup for testing within the project's framework.

```csharp
using mPAS.Infrastructure.TestCommon;  // Required
using Xunit;
using Xunit.Abstractions;

public class MyServiceTests : TestSpecBase<MyService>  // ← ALWAYS inherit
{
    public MyServiceTests(ITestOutputHelper testOutputHelper) 
        : base(testOutputHelper)  // ← ALWAYS call base
    {
    }
    
    [Fact]
    public void Test_Scenario_Expected()
    {
        // Arrange - use Fixture, Mock<T>(), Create<T>()
        // Act
        // Assert
    }
}
```

--------------------------------

### Complex Operation Testing with Multiple Mocks

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/revisions_short_path=6aea449

This example showcases how to test a complex asynchronous operation involving multiple dependencies (IRepo and ILogger) using AutoFixture's `[Frozen]` attribute to inject mocked instances. It verifies interactions with the mocked repository and logger.

```csharp
[Theory, DefaultAutoData]
public async Task ComplexOperation([Frozen] IRepo repo, [Frozen] ILogger logger, MyService sut)
{
// Arrange
var entity = Create<Entity>();
repo.GetAsync(Arg.Any<int>()).Returns(entity);

// Act
await sut.ProcessAsync(123);

// Assert
await repo.Received(1).GetAsync(123);
logger.Received().Log(LogLevel.Information, Arg.Any<string>());
}
```

--------------------------------

### JSON Test Data Format Example

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/revisions

Sample format for JSON test data used in data-driven tests. Each object represents a test case with input and expected outcome.

```json
[
{ "input": "value1", "expected": 123 },
{ "input": "value2", "expected": 456 }
]
```

--------------------------------

### C# HTTP Testing Extensions for Deserialization

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/revisions_short_path=6aea449

Provides examples of using HTTP testing extensions to deserialize JSON responses. It shows how to handle camelCase JSON properties and deserialize from HttpResponseMessage content or HttpContent.

```csharp
// Deserialize with camelCase handling  
var response = await httpClient.GetAsync("/api/endpoint");  
var data = await response.Deserialize<MyResponseModel>();  
  
// Or from content  
var data = await httpContent.Deserialize<MyResponseModel>();
```

--------------------------------

### C# DefaultAutoData Attribute Usage Examples

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/revisions_short_path=6aea449

Demonstrates various ways to use the DefaultAutoData attribute in C# for generating test data, including basic usage, frozen dependencies, custom customizations, and complex scenarios with multiple parameters.

```csharp
// Basic usage with auto-generated parameters
[Theory, DefaultAutoData]
public void Test_WithAutoData(string name, int age, bool isActive)
{
 Assert.NotNull(name);
 Assert.InRange(age, int.MinValue, int.MaxValue);
}

// With frozen dependencies
[Theory, DefaultAutoData]
public async Task Test_WithFrozenMock(
 [Frozen] IUserRepository repository,
 [Frozen] ILogger<UserService> logger,
 User testUser,
 UserService sut)
{
 // Arrange
 repository.GetByIdAsync(testUser.Id).Returns(testUser);

 // Act
 var result = await sut.GetUserAsync(testUser.Id);

 // Assert
 Assert.Equal(testUser.Id, result.Id);
 await repository.Received(1).GetByIdAsync(testUser.Id);
 logger.Received().Log(
 LogLevel.Information,
 Arg.Any<EventId>(),
 Arg.Is<object>(o => o.ToString()!.Contains(testUser.Id.ToString())),
 null,
 Arg.Any<Func<object, Exception?, string>>());
}

// With custom customization
public class EmailCustomization : ICustomization
{
 public void Customize(IFixture fixture)
 {
 fixture.Customize<User>(composer => composer
 .With(u => u.Email, "test@example.com")
 .With(u => u.IsVerified, true));
 }
}

[Theory, DefaultAutoData(typeof(EmailCustomization))]
public void Test_WithCustomization(User user)
{
 Assert.Equal("test@example.com", user.Email);
 Assert.True(user.IsVerified);
}

// Complex scenario with multiple parameters
[Theory, DefaultAutoData]
public async Task ProcessOrder_CompleteScenario(
 [Frozen] IOrderRepository orderRepo,
 [Frozen] IProductRepository productRepo,
 [Frozen] IEmailService emailService,
 [Frozen] ILogger<OrderProcessor> logger,
 Order order,
 List<Product> products,
 OrderProcessor sut)
{
 // Arrange
 productRepo.GetByIdsAsync(Arg.Any<List<int>>()).Returns(products);
 orderRepo.CreateAsync(Arg.Any<Order>()).Returns(order.Id);

 // Act
 var result = await sut.ProcessOrderAsync(order, products.Select(p => p.Id).ToList());

 // Assert
 Assert.Equal(order.Id, result.OrderId);
 await orderRepo.Received(1).CreateAsync(Arg.Any<Order>());
 await emailService.Received(1).SendOrderConfirmationAsync(order.Id);
}
```

--------------------------------

### Mock gRPC Service for Testing

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/revisions_short_path=6aea449

Demonstrates how to mock a gRPC service dependency within a unit test using AutoFixture and Moq. The example shows how to freeze a mocked gRPC service and configure its behavior, such as returning a specific response for a method call, enabling isolated testing of the service under test.

```csharp
[Theory, DefaultAutoData]
public async Task GrpcTest([Frozen] IMyGrpcService grpcService, MyService sut)
{
    var response = Create<MyGrpcResponse>();
    grpcService.GetDataAsync(Arg.Any<MyRequest>(), null, null, CancellationToken.None)
        .Returns(response.ToAsyncUnaryCall());
    
    var result = await sut.ProcessData();
    Assert.NotNull(result);
}
```

--------------------------------

### DefaultAutoData Attribute Usage

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/revisions

Demonstrates using the DefaultAutoData attribute to automatically generate test data for method parameters. Includes examples with frozen dependencies and custom customization to control data generation.

```C#
[Theory, DefaultAutoData]
public void Test_WithAutoData(string name, int age, bool isActive)
{
Assert.NotNull(name);
Assert.InRange(age, int.MinValue, int.MaxValue);
}

[Theory, DefaultAutoData]
public async Task Test_WithFrozenMock(
[Frozen] IUserRepository repository,
[Frozen] ILogger<UserService> logger,
User testUser,
UserService sut)
{
// Arrange
repository.GetByIdAsync(testUser.Id).Returns(testUser);

// Act
var result = await sut.GetUserAsync(testUser.Id);

// Assert
Assert.Equal(testUser.Id, result.Id);
await repository.Received(1).GetByIdAsync(testUser.Id);
logger.Received().Log(
LogLevel.Information,
Arg.Any<EventId>(),
Arg.Is<object>(o => o.ToString()!.Contains(testUser.Id.ToString())),
null,
Arg.Any<Func<object, Exception?, string>>());
}
```

--------------------------------

### Test Circular References in C#

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/74166199921f4bcac96ae0f70f5a8a1f46766f3d

Examples showing how to handle circular references in object graphs when using AutoFixture for testing. Demonstrates manual handling using Build() and AutoFixture's built-in recursion handling.

```csharp
public class Order
{
    public int Id { get; set; }
    public Customer Customer { get; set; } = null!;
    public List<OrderLine> Lines { get; set; } = new();
}

public class Customer
{
    public int Id { get; set; }
    public string Name { get; set; } = string.Empty;
    public List<Order> Orders { get; set; } = new(); // Circular reference
}
```

```csharp
[Fact]
public void CreateOrder_WithCircularReferences_HandlesCorrectly()
{
    // Option 1: Use Build to avoid circular references
    var order = Build<Order>()
        .Without(o => o.Customer) // Omit circular reference
        .With(o => o.Lines, CreateMany<OrderLine>(3).ToList())
        .Create();
    
    order.Customer = Build<Customer>()
        .Without(c => c.Orders) // Omit circular reference
        .Create();
    
    Assert.NotNull(order.Customer);
    Assert.Equal(3, order.Lines.Count);
}
```

```csharp
[Theory, DefaultAutoData]
public void CreateOrder_AutoFixtureHandlesCircular([Frozen] IOrderRepository repo, Order order)
{
    // AutoFixture's OmitOnRecursionBehavior (enabled by default) handles this
    Assert.NotNull(order);
}
```

--------------------------------

### JSON Data Structure Example

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/revisions_source=1

This JSON structure represents an array of objects, where each object contains an 'input' string and an 'expected' integer value. It is commonly used for defining test cases or configuration data.

```json
[
  { "input": "value1", "expected": 123 },
  { "input": "value2", "expected": 456 }
]
```

--------------------------------

### Use DefaultAutoData Attribute in C# Tests

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/74166199921f4bcac96ae0f70f5a8a1f46766f3d

Usage examples of the DefaultAutoData attribute for parameterized tests in C#. Demonstrates basic parameter injection, frozen dependencies, customizations, and complex scenarios with multiple dependencies.

```csharp
[Theory, DefaultAutoData]
public void Test_WithAutoData(string name, int age, bool isActive)
{
    Assert.NotNull(name);
    Assert.InRange(age, int.MinValue, int.MaxValue);
}
```

```csharp
[Theory, DefaultAutoData]
public async Task Test_WithFrozenMock(
    [Frozen] IUserRepository repository,
    [Frozen] ILogger logger,
    User testUser,
    UserService sut)
{
    // Arrange
    repository.GetByIdAsync(testUser.Id).Returns(testUser);
    
    // Act
    var result = await sut.GetUserAsync(testUser.Id);
    
    // Assert
    Assert.Equal(testUser.Id, result.Id);
    await repository.Received(1).GetByIdAsync(testUser.Id);
    logger.Received().Log(
        LogLevel.Information,
        Arg.Any<EventId>(),
        Arg.Is<object>(o => o.ToString()!.Contains(testUser.Id.ToString())),
        null,
        Arg.Any<Func<object, Exception?, string>>());
}
```

```csharp
public class EmailCustomization : ICustomization
{
    public void Customize(IFixture fixture)
    {
        fixture.Customize(composer => composer
            .With(u => u.Email, "test@example.com")
            .With(u => u.IsVerified, true));
    }
}

[Theory, DefaultAutoData(typeof(EmailCustomization))]
public void Test_WithCustomization(User user)
{
    Assert.Equal("test@example.com", user.Email);
    Assert.True(user.IsVerified);
}
```

```csharp
[Theory, DefaultAutoData]
public async Task ProcessOrder_CompleteScenario(
    [Frozen] IOrderRepository orderRepo,
    [Frozen] IProductRepository productRepo,
    [Frozen] IEmailService emailService,
    [Frozen] ILogger logger,
    Order order,
    List<Product> products,
    OrderProcessor sut)
{
    // Arrange
    productRepo.GetByIdsAsync(Arg.Any<List<Guid>>()).Returns(products);
    orderRepo.CreateAsync(Arg.Any<Order>()).Returns(order.Id);
    
    // Act
    var result = await sut.ProcessOrderAsync(order, products.Select(p => p.Id).ToList());
    
    // Assert
    Assert.Equal(order.Id, result.OrderId);
    await orderRepo.Received(1).CreateAsync(Arg.Any<Order>());
    await emailService.Received(1).SendOrderConfirmationAsync(order.Id);
}
```

--------------------------------

### Implement Custom AutoFixture Interface in C#

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/raw/74166199921f4bcac96ae0f70f5a8a1f46766f3d/test

This example shows how to implement a custom interface, IFixtureExt, which wraps an AutoFixture instance. It provides methods for creating, mocking, and freezing objects, simplifying common AutoFixture operations within a test base class. This promotes reusability and a cleaner test structure.

```csharp
public interface IFixtureExt
{
    IFixture Fixture { get; }
    TMock Mock<TMock>(bool freezeIt = true) where TMock : class;
    TMock Create<TMock>();
    IEnumerable<TMock> CreateMany<TMock>();
    IEnumerable<TMock> CreateMany<TMock>(int count);
    TMock Freeze<TMock>();
}

public class FixtureExt : IFixtureExt
{
    private readonly Fixture _fixture;

    public FixtureExt()
    {
        _fixture = new Fixture();
    }

    public IFixture Fixture => _fixture;

    public TMock Mock<TMock>(bool freezeIt = true) where TMock : class
    {
        if (freezeIt)
        {
            return _fixture.Freeze<TMock>();
        }
        return _fixture.Create<TMock>();
    }

    public TMock Create<TMock>() => _fixture.Create<TMock>();

    public IEnumerable<TMock> CreateMany<TMock>() => _fixture.CreateMany<TMock>();

    public IEnumerable<TMock> CreateMany<TMock>(int count) => _fixture.CreateMany<TMock>(count);

    public TMock Freeze<TMock>() => _fixture.Freeze<TMock>();
}

// Usage in tests
public class CustomTestBase<T> : IFixtureExt where T : class
{
    private readonly FixtureExt _fixtureExt;

    public CustomTestBase()
    {
        _fixtureExt = new FixtureExt();
    }

    public IFixture Fixture => _fixtureExt.Fixture;

    public TMock Mock<TMock>(bool freezeIt = true) => _fixtureExt.Mock<TMock>(freezeIt);

    public TMock Create<TMock>() => _fixtureExt.Create<TMock>();

    public IEnumerable<TMock> CreateMany<TMock>() => _fixtureExt.CreateMany<TMock>();

    public IEnumerable<TMock> CreateMany<TMock>(int count) => _fixtureExt.CreateMany<TMock>(count);

    public TMock Freeze<TMock>() => _fixtureExt.Freeze<TMock>();

    [Fact]
    public void CustomTestExample()
    {
        var mock = Mock<IRepository>();
        var data = Create<Product>();
        var dataList = CreateMany<Product>(5);
        
        Assert.NotNull(data);
        Assert.Equal(5, dataList.Count());
    }
}
```

--------------------------------

### Create Fake EF Core DbContext Static Method in C#

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/raw/74166199921f4bcac96ae0f70f5a8a1f46766f3d/test

Static method to create an in-memory EF Core DbContext without extending classes. Depends on Entity Framework Core and optional AutoFixture. Inputs are database name, optional fixture, and seed function; output is a DbContext instance. Limitation: Requires manual fixture setup if needed for seeding.

```csharp
public static T GetFakeDb<T>(
    string databaseName,
    IFixtureExt? fixtureExt = null,
    Action<IFixtureExt?, T>? seedFunc = null) where T : DbContext

[Fact]
public void TestWithoutTestSpecBase()
{
    // Arrange
    var fixture = new FixtureExt();
    var context = EFFakeExtention.GetFakeDb<MyDbContext>(
        databaseName: "TestDb",
        fixtureExt: fixture,
        seedFunc: (f, db) =>
        {
            var products = f!.CreateMany<Product>(3).ToList();
            db.Products.AddRange(products);
            db.SaveChanges();
        });

    var repository = new ProductRepository(context);

    // Act
    var result = repository.GetAll();

    // Assert
    Assert.Equal(3, result.Count);
}
```

--------------------------------

### GetFakeDb() - Static Method without TestSpecBase (C#)

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/revisions_short_path=6aea449

Creates an in-memory EF Core DbContext without requiring a specific test base class. This static method is useful for simpler test setups or when not inheriting from TestSpecBase. It can optionally take an IFixtureExt and a seed function.

```csharp
public static T GetFakeDb<T>( string databaseName, IFixtureExt? fixtureExt = null, Action<IFixtureExt?, T>? seedFunc = null) where T : DbContext 

[Fact] 
public void TestWithoutTestSpecBase() {
    // Arrange
    var fixture = new FixtureExt();
    var context = EFFakeExtention.GetFakeDb(
        databaseName: "TestDb",
        fixtureExt: fixture,
        seedFunc: (f, db) => {
            var products = f!.CreateMany(3).ToList();
            db.Products.AddRange(products);
            db.SaveChanges();
        });

    var repository = new ProductRepository(context);

    // Act
    var result = repository.GetAll();

    // Assert
    Assert.Equal(3, result.Count);

}
```

--------------------------------

### Implement IFixtureExt for Custom Test Fixtures in C#

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/index

Provides a complete implementation example of the IFixtureExt interface within a CustomTestBase class. This allows for customized test fixture behavior by leveraging the underlying FixtureExt class. It includes methods for mocking, creating single objects, creating collections, and freezing dependencies.

```csharp
public class CustomTestBase<T> : IFixtureExt where T : class
{
    private readonly FixtureExt _fixtureExt;

    public CustomTestBase()
    {
        _fixtureExt = new FixtureExt();
    }

    public IFixture Fixture => _fixtureExt.Fixture;

    public TMock Mock<TMock>(bool freezeIt = true) => _fixtureExt.Mock<TMock>(freezeIt);

    public TMock Create<TMock>() => _fixtureExt.Create<TMock>();

    public IEnumerable<TMock> CreateMany<TMock>() => _fixtureExt.CreateMany<TMock>();

    public IEnumerable<TMock> CreateMany<TMock>(int count) => _fixtureExt.CreateMany<TMock>(count);

    public TMock Freeze<TMock>() => _fixtureExt.Freeze<TMock>();

    // Usage in tests
    [Fact]
    public void CustomTestExample()
    {
        var mock = Mock<IRepository>();
        var data = Create<Product>();
        var dataList = CreateMany<Product>(5);
        
        Assert.NotNull(data);
        Assert.Equal(5, dataList.Count());
    }

}
```

--------------------------------

### Deserializing HTTP Content to User List in C#

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/raw/74166199921f4bcac96ae0f70f5a8a1f46766f3d/test

Example of using the Deserialize<T>() extension method to convert HTTP content JSON into a strongly-typed list of User objects with camelCase handling. Depends on mPAS.Infrastructure.TestCommon.Extensions namespace and HttpContent class. Takes HttpContent as input, returns Task<List<User>>, assumes valid JSON matching the User model; limitations include potential deserialization errors for mismatched schemas.

```csharp
public class ApiClientTests : TestSpecBase<ApiClient>
{
    private readonly HttpClient _httpClient;

    public ApiClientTests(ITestOutputHelper testOutputHelper)
        : base(testOutputHelper)
    {
        _httpClient = Mock<HttpClient>();
    }

    [Fact]
    public async Task GetUsers_Success_DeserializesResponse()
    {
        // Arrange
        var jsonContent = new StringContent(
            @"[{\"name\":\"John Doe\",\"age\":30},{\"name\":\"Jane Smith\",\"age\":25}]",
            System.Text.Encoding.UTF8,
            "application/json");

        // Act
        var users = await jsonContent.Deserialize<List<User>>();

        // Assert
        Assert.NotNull(users);
        Assert.Equal(2, users.Count);
        Assert.Equal("John Doe", users[0].Name);
        Assert.Equal(30, users[0].Age);
    }
}
```

--------------------------------

### Basic Unit Test with TestSpecBase<T>

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/revisions_source=1

Demonstrates the fundamental structure of a unit test using `TestSpecBase<T>`. It shows how to inherit from the base class, pass `ITestOutputHelper` to the constructor, and write a basic test method where the System Under Test (Sut) is automatically created with mocked dependencies.

```csharp
public class MyServiceTests : TestSpecBase<MyService>
{
public MyServiceTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper) { }

[Fact]
public void MyTest()
{
// Sut is MyService with all dependencies mocked automatically
var result = Sut.DoSomething();
Assert.NotNull(result);
}
}
```

--------------------------------

### C# Unit Test with TestSpecBase

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/raw/74166199921f4bcac96ae0f70f5a8a1f46766f3d/test

Demonstrates a basic unit test using TestSpecBase, showing how to access the System Under Test (Sut) and mocked dependencies with AutoFixture and NSubstitute.

```csharp
public class MyServiceTests : TestSpecBase<MyService>
{
    public MyServiceTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper) { }

    [Fact]
    public void MyTest()
    {
        // Sut is MyService with all dependencies mocked automatically
        var result = Sut.DoSomething();
        Assert.NotNull(result);
    }
}
```

--------------------------------

### C# Basic Usage with TestSpecBase

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/revisions_short_path=6aea449

Demonstrates basic usage of TestSpecBase for creating and testing a service. It shows how to automatically mock dependencies and perform assertions.

```csharp
public class MyServiceTests : TestSpecBase<MyService>  
{
  public MyServiceTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper) { }
  
  [Fact]  
  public void MyTest()  
  {
  // Sut is MyService with all dependencies mocked automatically  
  var result = Sut.DoSomething();  
  Assert.NotNull(result);  
  }
}
```

--------------------------------

### Integration testing with multiple dependencies

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/revisions_source=1

Illustrates complex integration testing scenarios using AutoFixture's [Frozen] attribute to inject mock dependencies. Shows how to test complete workflows involving multiple services and repositories, with proper arrangement, act, and assert phases.

```csharp
// Complex scenario with multiple parameters
[Theory, DefaultAutoData]
public async Task ProcessOrder_CompleteScenario(
    [Frozen] IOrderRepository orderRepo,
    [Frozen] IProductRepository productRepo,
    [Frozen] IEmailService emailService,
    [Frozen] ILogger<OrderProcessor> logger,
    Order order,
    List<Product> products,
    OrderProcessor sut)
{
    // Arrange
    productRepo.GetByIdsAsync(Arg.Any<List<int>>()).Returns(products);
    orderRepo.CreateAsync(Arg.Any<Order>()).Returns(order.Id);

    // Act
    var result = await sut.ProcessOrderAsync(order, products.Select(p => p.Id).ToList());

    // Assert
    Assert.Equal(order.Id, result.OrderId);
    await orderRepo.Received(1).CreateAsync(Arg.Any<Order>());
    await emailService.Received(1).SendOrderConfirmationAsync(order.Id);
}
```

--------------------------------

### Sample JSON Test Data Format (JSON)

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/index

Provides an example of the JSON structure expected by JsonDataAttribute, containing input and expected values for each test case.

```json
[\n  { "input": "value1", "expected": 123 },\n  { "input": "value2", "expected": 456 }\n]
```

--------------------------------

### Add Products to Database

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/revisions

Illustrates adding a list of products to a database and saving changes using Entity Framework Core in C#.

```C#
db.Products.AddRange(products);
 db.SaveChanges();
```

--------------------------------

### C# gRPC Testing with AutoFixture

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/revisions_short_path=6aea449

Demonstrates testing gRPC services using AutoFixture and XUnit. It shows how to mock gRPC service responses and integrate them into service processing logic.

```csharp
[Theory, DefaultAutoData]  
public async Task GrpcTest([Frozen] IMyGrpcService grpcService, MyService sut)  
{
  var response = Create<MyGrpcResponse>();  
  grpcService.GetDataAsync(Arg.Any<MyRequest>(), null, null, CancellationToken.None)  
  .Returns(response.ToAsyncUnaryCall());  
  
  var result = await sut.ProcessData();  
  Assert.NotNull(result);  
}
```

--------------------------------

### Example: Complex Test with Auto-Injected DbContext

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/revisions

Demonstrates a more complex test scenario where the in-memory DbContext is created using GetFakeDbUsingFixture and automatically integrated with AutoFixture. This allows for easier creation of dependent objects that might rely on the DbContext.

```csharp
[Fact]
public void ComplexTest_WithAutoInjectedDbContext()
{
  // Arrange
  var fixture = new Fixture();
  var context = fixture.GetFakeDbUsingFixture<MyDbContext>(
  seedFunc: (f, db) =>
  {
  var products = f!.CreateMany<Product>(5);
  // ... further seeding logic can go here
  });
  
  // Now, if ProductRepository can be created by fixture, it would automatically receive the context.
  // var repository = fixture.Create<ProductRepository>(); 
  // ... rest of the test
}

```

--------------------------------

### C# Unit Test with Mocked Dependencies

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/revisions_short_path=6aea449

Presents a common pattern for unit testing in C# using mocked dependencies. It utilizes TestSpecBase to manage the System Under Test (SUT) and mocks for its dependencies, facilitating Arrange-Act-Assert structure.

```csharp
public class MyServiceTests : TestSpecBase<MyService>  
{
  private readonly IRepository _repository;  
  
  public MyServiceTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper)  
  {
  _repository = Mock<IRepository>();  
  }
  
  [Fact]  
  public async Task Method_Scenario_ExpectedResult()  
  {
  // Arrange  
  var testData = Create<MyEntity>();  
  _repository.GetAsync(Arg.Any<int>()).Returns(testData);  
  
  // Act  
  var result = await Sut.ProcessAsync(123);  
  
  // Assert  
  Assert.Equal(testData.Value, result.Value);  
  await _repository.Received(1).GetAsync(123);  
  }
}
```

--------------------------------

### Data-Driven Test Using JsonFolderDataAttribute (C#)

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/index

Example of a Theory that loads validation scenarios from a specific folder using JsonFolderDataAttribute. Each JSON file provides ValidationTestData, and the test asserts the validation outcome and possible error messages.

```csharp
[Theory]\n[JsonFolderData("ValidationScenarios")]\npublic void Validate_Scenario_ExpectedResult(ValidationTestData data)\n{\n    var validator = Create<MyValidator>();\n    \n    var result = validator.Validate(data.Input);\n    \n    Assert.Equal(data.IsValid, result.IsValid);\n    if (!data.IsValid)\n    {\n        Assert.Contains(data.ExpectedError, result.Errors.Select(e => e.Message));\n    }\n}
```

--------------------------------

### C# Data-Driven Testing with ExcelDataAttribute

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/raw/74166199921f4bcac96ae0f70f5a8a1f46766f3d/test

Shows how to load test data from an Excel file using the ExcelDataAttribute, specifying column headers as parameters.

```csharp
[Theory]
[ExcelData]
public void ProcessExcelData(string col1, int col2, bool col3)
{
    // Row 1: Headers (ignored)
    // Row 2+: Data (parameters match column order)
}
```

--------------------------------

### C# Testing with Circular References Example

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/revisions_short_path=6aea449

Illustrates how to handle circular references in C# tests using AutoFixture. It shows manual omission of references and relies on AutoFixture's default recursion behavior.

```csharp
public class Order
{
 public int Id { get; set; }
 public Customer Customer { get; set; } = null!;
 public List<OrderLine> Lines { get; set; } = new();
}

public class Customer
{
 public int Id { get; set; }
 public string Name { get; set; } = string.Empty;
 public List<Order> Orders { get; set; } = new(); // Circular reference
}

public class OrderTests : TestSpecBase<OrderService>
{
 public OrderTests(ITestOutputHelper output) : base(output) { }

 [Fact]
 public void CreateOrder_WithCircularReferences_HandlesCorrectly()
 {
 // Option 1: Use Build to avoid circular references
 var order = Build<Order>()
 .Without(o => o.Customer) // Omit circular reference
 .With(o => o.Lines, CreateMany<OrderLine>(3).ToList())
 .Create();

 order.Customer = Build<Customer>()
 .Without(c => c.Orders) // Omit circular reference
 .Create();

 Assert.NotNull(order.Customer);
 Assert.Equal(3, order.Lines.Count);
 }

 [Theory, DefaultAutoData]
 public void CreateOrder_AutoFixtureHandlesCircular([Frozen] IOrderRepository repo, Order order)
 {
 // AutoFixture's OmitOnRecursionBehavior (enabled by default) handles this
 Assert.NotNull(order);
 }
}
```

--------------------------------

### Implement IFixtureExt Interface in C#

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/74166199921f4bcac96ae0f70f5a8a1f46766f3d

Implementation of the IFixtureExt interface that provides helper methods for creating and mocking objects in tests. It wraps a FixtureExt instance and exposes methods for creating single or multiple instances, freezing objects, and creating mocks.

```csharp
public class CustomTestBase : IFixtureExt where T : class {
    private readonly FixtureExt _fixtureExt;
    
    public CustomTestBase()
    {
        _fixtureExt = new FixtureExt();
    }
    
    public IFixture Fixture => _fixtureExt.Fixture;
    
    public TMock Mock<TMock>(bool freezeIt = true) => _fixtureExt.Mock<TMock>(freezeIt);
    
    public TMock Create<TMock>() => _fixtureExt.Create<TMock>();
    
    public IEnumerable<TMock> CreateMany<TMock>() => _fixtureExt.CreateMany<TMock>();
    
    public IEnumerable<TMock> CreateMany<TMock>(int count) => _fixtureExt.CreateMany<TMock>(count);
    
    public TMock Freeze<TMock>() => _fixtureExt.Freeze<TMock>();
}
```

--------------------------------

### Required Using Directives for Test Classes

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/revisions_short_path=6aea449

Essential using directives for test classes to ensure compatibility with the TestSpecBase<T> and XUnit frameworks.

```C#
using mPAS.Infrastructure.TestCommon;  // Required for TestSpecBase<T>
using Xunit;
using Xunit.Abstractions;
```

--------------------------------

### Auto-Generated Data Test with DefaultAutoData in C#

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/index

This C# example showcases using the DefaultAutoData attribute for data-driven tests. It leverages AutoFixture and XUnit to automatically generate test data and mock dependencies, including reusing specific instances with [Frozen].

```csharp
[Theory, DefaultAutoData]
public void Test_AutoGenerated([Frozen] IRepository repo, MyService sut)
{
    // [Frozen] ensures same mock instance used everywhere
    // sut is auto-created with dependencies
    repo.GetData().Returns(new Data());
    
    var result = sut.Process();
    
    Assert.NotNull(result);
    repo.Received(1).GetData();
}
```

--------------------------------

### Create Standalone In-Memory DbContext

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/74166199921f4bcac96ae0f70f5a8a1f46766f3d

Static method for creating an in-memory DbContext without requiring TestSpecBase inheritance. Accepts database name, optional fixture, and optional seed function. Enables unit testing without specific base class dependencies.

```csharp
[Fact] public void TestWithoutTestSpecBase() { // Arrange var fixture = new FixtureExt(); var context = EFFakeExtention.GetFakeDb( databaseName: "TestDb", fixtureExt: fixture, seedFunc: (f, db) => { var products = f!.CreateMany(3).ToList(); db.Products.AddRange(products); db.SaveChanges(); });

var repository = new ProductRepository(context);

// Act
var result = repository.GetAll();

// Assert
Assert.Equal(3, result.Count);

}
```

--------------------------------

### C# HTTP Deserialization

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/raw/74166199921f4bcac96ae0f70f5a8a1f46766f3d/test

Illustrates deserializing HTTP response content using extensions, including support for camelCase handling.

```csharp
var response = await httpClient.GetAsync("/api/endpoint");
var data = await response.Deserialize<MyResponseModel>();

// Or from content
var data = await httpContent.Deserialize<MyResponseModel>();
```

--------------------------------

### C# Data-Driven Testing with JsonFolderDataAttribute

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/raw/74166199921f4bcac96ae0f70f5a8a1f46766f3d/test

Demonstrates how to load test data from multiple JSON files within a folder using JsonFolderDataAttribute.

```csharp
[Theory]
[JsonFolderData]
public void ProcessScenarios(TestScenario scenario)
{
    // Each .json file in folder = one test case
}
```

--------------------------------

### Create In-Memory EF Core DbContext for Testing

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/revisions_short_path=6aea449

Generates an in-memory Entity Framework Core DbContext for efficient unit testing. Allows for seeding initial data.

```csharp
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.Extensions.DependencyInjection;
using System;
using System.Threading.Tasks;

public static class EFFakeExtension
{
    public static T GetFakeDb<T>(
        this IFixtureExt fixtureExt,
        string databaseName,
        Func<DbContextOptions<T>, T> dbContextFactory,
        Action<IFixtureExt, T>? seedFunc = null)
        where T : DbContext
    {
        var options = new DbContextOptionsBuilder<T>()
            .UseInMemoryDatabase(databaseName)
            .ReplaceService<IResettableService, InMemoryDatabaseResettableService>()
            .Options;

        var dbContext = dbContextFactory(options);
        
        seedFunc?.Invoke(fixtureExt, dbContext);

        return dbContext;
    }
}
```

```csharp
using Microsoft.EntityFrameworkCore;

public class MyDbContext : DbContext
{
    public MyDbContext(DbContextOptions<MyDbContext> options) : base(options) { }
    public DbSet<Product> Products { get; set; } = null!;
    public DbSet<Order> Orders { get; set; } = null!;
}

public class ProductRepositoryTests : TestSpecBase<ProductRepository>
{
    private readonly MyDbContext _context;

    public ProductRepositoryTests(ITestOutputHelper testOutputHelper)
    : base(testOutputHelper)
    {
        _context = this.GetFakeDb(
        databaseName: "TestDb-" + Guid.NewGuid(),
        dbContextFactory: options => new MyDbContext(options),
        seedFunc: (fixture, db) =>
        {
            // Seed test data
            var products = fixture.CreateMany<Product>(5).ToList();
            db.Products.AddRange(products);
            db.SaveChanges();
        });
    }

    [Fact]
    public async Task GetProduct_ExistingId_ReturnsProduct()
    {
        // Arrange
        var testProduct = Create<Product>();
        _context.Products.Add(testProduct);
        await _context.SaveChangesAsync();

        // Act
        var result = await Sut.GetByIdAsync(testProduct.Id);

        // Assert
        Assert.NotNull(result);
        Assert.Equal(testProduct.Id, result.Id);
        Assert.Equal(testProduct.Name, result.Name);
    }

    [Fact]
    public async Task GetProducts_MultipleProducts_ReturnsAll()
    {
        // Arrange
        var products = CreateMany<Product>(10).ToList();
        _context.Products.AddRange(products);
        await _context.SaveChangesAsync();

```

--------------------------------

### Ensuring Mock Receives Calls with [Frozen]

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/raw/74166199921f4bcac96ae0f70f5a8a1f46766f3d/test

Explains a common pitfall in mocking where different instances of a mocked dependency are used in the test setup and the system under test. It highlights the importance of the [Frozen] attribute to ensure the same mock instance is injected.

```csharp
// Use [Frozen] to ensure same instance
[Theory, DefaultAutoData]
public void Test([Frozen] IRepository repo, MyService sut) // ← [Frozen] critical!
{
    repo.GetData().Returns(new Data());
    sut.Process(); // Uses same repo instance
    repo.Received(1).GetData(); // ✓ Works

// Without [Frozen]:
public void Test()
{
    var repo = Mock<IRepository>(); // New instance
    var sut = new MyService(Mock<IRepository>()); // Different instance!
    repo.Received(1).GetData(); // ✗ Fails - different instances
}
```

--------------------------------

### C# Data-Driven Unit Test with JsonFolderData

Source: https://gist.github.com/MiteshDhiran/ac29338c529e53307142b89d821557b0/revisions_source=1

This C# example showcases a data-driven unit test using the Theory attribute and JsonFolderDataAttribute. It reads test data from JSON files and uses it to validate a method's behavior, asserting expected outcomes based on the input data.

```csharp
[Theory]
[JsonFolderData("ValidationScenarios")]
public void Validate_Scenario_ExpectedResult(ValidationTestData data)
{
  var validator = Create<MyValidator>();

  var result = validator.Validate(data.Input);

  Assert.Equal(data.IsValid, result.IsValid);
  if (!data.IsValid)
  {
    Assert.Contains(data.ExpectedError, result.Errors.Select(e => e.Message));
  }
}
```
Tokens:
Raw