ProductService tested and stable

LiteCharms.Features.MidrandBooks.Tests/LiteCharms.Features.MidrandBooks.Tests.csproj

@@ -39,6 +39,7 @@
   </ItemGroup>
 
   <ItemGroup>
+    <Using Include="System.Text.Json" />
     <Using Include="System.Diagnostics" />
     <Using Include="Xunit" />
   </ItemGroup>

LiteCharms.Features.MidrandBooks.Tests/ProductServiceFeatureTest.cs

@@ -1,7 +1,6 @@
 using LiteCharms.Features.MidrandBooks.Products;
 using LiteCharms.Features.MidrandBooks.Products.Models;
 using LiteCharms.Features.Models;
-using System.Text.Json;
 
 namespace LiteCharms.Features.MidrandBooks.Tests;
 
@@ -9,6 +8,59 @@ public class ProductServiceFeatureTest(Fixture fixture, ITestOutputHelper output
 {
     private readonly ProductService productService = fixture.Services.GetRequiredService<ProductService>();
 
+    [IntegrationFact]
+    public async Task GetProductPriceAsync_ShouldReturn_RetultOneProductPrice()
+    {
+        var result = await productService.GetProductPriceAsync(2, fixture.CancellationToken);
+
+        Assert.True(result.IsSuccess);
+        Assert.NotNull(result.Value);
+
+        output.WriteLine(JsonSerializer.Serialize(result.Value));
+    }
+
+    [IntegrationFact]
+    public async Task GetProductPricesAsync_ShouldReturn_RetultProductPriceList()
+    {
+        var result = await productService.GetProductPricesAsync(2, fixture.CancellationToken);
+
+        Assert.True(result.IsSuccess);
+        Assert.NotEmpty(result.Value);
+
+        output.WriteLine(JsonSerializer.Serialize(result.Value));
+    }
+
+    [IntegrationFact]
+    public async Task SearchProductsAsync_ShouldReturn_RetultMatchingProducts()
+    {
+        var filter = new ProductFilter
+        {
+            Name = "system",
+            Manufacturer = "techwave",
+            SerialNumber = "2024",
+            MinPrice = 10,
+            MaxPrice = 30    
+        };
+
+        var result = await productService.SearchProductsAsync(filter, fixture.CancellationToken);
+
+        Assert.True(result.IsSuccess);
+        Assert.NotEmpty(result.Value);
+
+        output.WriteLine(JsonSerializer.Serialize(result.Value));
+    }
+
+    [IntegrationFact]
+    public async Task GetProductAsync_ShouldReturn_RetultOneProduct()
+    {
+        var result = await productService.GetProductAsync(2, fixture.CancellationToken);
+
+        Assert.True(result.IsSuccess);
+        Assert.NotNull(result.Value);
+
+        output.WriteLine(JsonSerializer.Serialize(result.Value));
+    }
+
     [IntegrationFact]
     public async Task GetProductsAsync_ShouldReturn_RetultProducts()
     {

LiteCharms.Features.MidrandBooks/Products/ProductService.cs

@@ -64,17 +64,22 @@ public sealed class ProductService(IDbContextFactory<MidrandBooksDbContext> cont
 
             var query = context.Products.AsQueryable();
 
+            var cultureInfo = CultureInfo.InvariantCulture;
+
+            if (!string.IsNullOrWhiteSpace(filter.Name))
+                query = query.Where(p => EF.Functions.ILike(p.Name!, $"%{filter.Name}%"));
+
             if (!string.IsNullOrWhiteSpace(filter.Title))
-                query = query.Where(p => p.Name!.Contains(filter.Title));
+                query = query.Where(p => EF.Functions.ILike(p.Name!, $"%{filter.Title}%"));
 
             if (!string.IsNullOrWhiteSpace(filter.Category))
-                query = query.Where(p => p.Categories!.Any(c => c == filter.Category));
+                query = query.Where(p => p.Categories.Contains(filter.Category));
 
             if (!string.IsNullOrWhiteSpace(filter.Manufacturer))
-                query = query.Where(p => p.Metadata!.Manufacturer == filter.Manufacturer);
+                query = query.Where(p => EF.Functions.ILike(p.Metadata!.Manufacturer!, $"%{filter.Manufacturer}%"));
 
             if (!string.IsNullOrWhiteSpace(filter.SerialNumber))
-                query = query.Where(p => p.Metadata!.SerialNumber == filter.SerialNumber);
+                query = query.Where(p => EF.Functions.ILike(p.Metadata!.SerialNumber!, $"%{filter.SerialNumber}%"));
 
             if (filter.MinPrice > 0)
                 query = query.Where(p => p.Prices!.Any(pr => pr.Amount >= filter.MinPrice && pr.Amount <= filter.MaxPrice));
@@ -165,7 +170,7 @@ public sealed class ProductService(IDbContextFactory<MidrandBooksDbContext> cont
         }
     }
 
-    public async ValueTask<Result<ProductPrice[]>> GetProductPriceAsync(long productId, CancellationToken cancellationToken = default)
+    public async ValueTask<Result<ProductPrice>> GetProductPriceAsync(long productId, CancellationToken cancellationToken = default)
     {
         try
         {
@@ -175,16 +180,16 @@ public sealed class ProductService(IDbContextFactory<MidrandBooksDbContext> cont
                 .AsNoTracking()
                 .OrderByDescending(p => p.CreatedAt)
                     .ThenBy(p => p.UpdatedAt)
-                .FirstOrDefaultAsync(p => p.ProductId == productId, cancellationToken);
+                .FirstOrDefaultAsync(p => p.ProductId == productId && p.Enabled, cancellationToken);
 
             return product is not null
-                ? Result.Ok(new[] { product.ToModel() })
-                : Result.Fail<ProductPrice[]>(new Error($"No price found for product with ID {productId}"));
+                ? Result.Ok(product.ToModel())
+                : Result.Fail<ProductPrice>(new Error($"No price found for product with ID {productId}"));
 
         }
         catch (Exception ex)
         {
-            return Result.Fail<ProductPrice[]>(new Error(ex.Message).CausedBy(ex));
+            return Result.Fail<ProductPrice>(new Error(ex.Message).CausedBy(ex));
         }
     }