How to write unit test for EF.Functions.ILike

 public async Task<List<CategoryMapping>> SearchAdvantage(GetCategoryMappingRequest request)

{

    using var uow = GetUow();

    var repo = GetRepository(uow);

    var query = repo.GetQueryable();

    if (!string.IsNullOrEmpty(request.Keyword))

    {

        var keyword = $"%{request.Keyword}%";

        query = query.Where(c =>

           EF.Functions.ILike(c.Title, keyword) ||

            (c.Parent != null && EF.Functions.ILike(c.Parent.Title, keyword))

        );

    }

    query = query.OrderBy(d => d.Title);

    return await query.ToListAsync();

}

1. Add the NuGet packages

dotnet add package Testcontainers.PostgreSql

dotnet add package Npgsql.EntityFrameworkCore.PostgreSQL

dotnet add package Microsoft.EntityFrameworkCore

dotnet add package Microsoft.EntityFrameworkCore.Design

dotnet add package xunit

dotnet add package Moq

2. Setup the test class

using Xunit;

using Microsoft.EntityFrameworkCore;

using Testcontainers.PostgreSql;

using System;

using System.Threading.Tasks;

using System.Collections.Generic;

using System.Linq;

public class CategoryMappingServiceAdvantageTests : IAsyncLifetime

{

    private PostgreSqlContainer _postgresContainer;

    private AdminPortalDBContext _context;

    private CategoryMappingService _service;

    public async Task InitializeAsync()

    {

        // Start a PostgreSQL test container

        _postgresContainer = new PostgreSqlBuilder()

            .WithDatabase("testdb")

            .WithUsername("postgres")

            .WithPassword("postgres")

            .Build();

        await _postgresContainer.StartAsync();

        // Setup DbContext with Npgsql

        var options = new DbContextOptionsBuilder<AdminPortalDBContext>()

            .UseNpgsql(_postgresContainer.GetConnectionString())

            .Options;

        _context = new AdminPortalDBContext(options);

        await _context.Database.EnsureCreatedAsync();

        // Seed test data

        var parent = new CategoryMapping { Id = Guid.NewGuid(), Title = "Electronics" };

        var child = new CategoryMapping { Id = Guid.NewGuid(), Title = "Phone", Parent = parent };

        _context.CategoryMappings.AddRange(parent, child);

        await _context.SaveChangesAsync();

        // Setup service with factory/delegate

        Func<IUnitOfWorkServiceFactory, IUnitOfWorkService> uowResolver =

            factory => factory.GetAdminPortalUowService();

        var uowFactoryMock = new Moq.Mock<IUnitOfWorkServiceFactory>();

        uowFactoryMock.Setup(f => f.GetAdminPortalUowService())

                      .Returns(new UnitOfWorkService(_context));

        _service = new CategoryMappingService(uowFactoryMock.Object, uowResolver);

    }

    public async Task DisposeAsync()

    {

        await _postgresContainer.StopAsync();

        _context.Dispose();

    }

    [Fact]

    public async Task SearchAdvantage_ShouldReturnResult_WhenKeywordMatchesParentTitle()

    {

        // Arrange

        var request = new GetCategoryMappingRequest { Keyword = "Electronics" };

        // Act

        var results = await _service.SearchAdvantage(request);

        // Assert

        Assert.True(results.Count >= 2);

        Assert.Contains(results, d => d.Title == "Phone");

    }

    [Fact]

    public async Task SearchAdvantage_ShouldReturnResult_WhenKeywordMatchesTitle()

    {

        // Arrange

        var request = new GetCategoryMappingRequest { Keyword = "Phone" };

        // Act

        var results = await _service.SearchAdvantage(request);

        // Assert

        Assert.Single(results);

        Assert.Equal("Phone", results.First().Title);

    }

}