Merge branch 'main' into dependabot/nuget/JsonApiToolkit/Microsoft.Identity.Abstractions-9.0.0

Author: erlendellefsen

CLAUDE.md

@@ -54,7 +54,7 @@ Documentation is built using DocFX and deployed to GitHub Pages. The documentati
 
 1. **JsonApiController** (`Controllers/JsonApiController.cs`)
    - Base controller for JSON:API endpoints
-   - Provides methods: `JsonApiOk()`, `JsonApiOkAsync()`, `JsonApiCreated()`, `JsonApiNotFound()`, etc.
+   - Provides methods: `JsonApiOk()`, `JsonApiQueryAsync()`, `JsonApiCreated()`, `JsonApiNotFound()`, etc.
    - Handles query parameter parsing and response formatting
    - Automatically applies filtering, sorting, pagination, and includes (filtering applies to main entity; includes load related resources)
 

JsonApiToolkit.Tests/Extensions/FilteredIncludeBuilderTests.cs

@@ -0,0 +1,212 @@
+using JsonApiToolkit.Extensions.Querying;
+using JsonApiToolkit.Models.Querying.Filtering;
+using Microsoft.EntityFrameworkCore;
+using Xunit;
+
+namespace JsonApiToolkit.Tests.Extensions;
+
+public class FilteredIncludeBuilderTests
+{
+    [Fact]
+    public void ApplyFilteredIncludes_WithNoIncludePaths_ReturnsOriginalQuery()
+    {
+        // Arrange
+        var query = CreateMockQueryable<TestEntity>();
+        List<string>? includePaths = null;
+        var includeFilters = new List<IncludeFilter>();
+
+        // Act
+        var result = query.ApplyFilteredIncludes(includePaths, includeFilters);
+
+        // Assert
+        Assert.Same(query, result);
+    }
+
+    [Fact]
+    public void ApplyFilteredIncludes_WithEmptyIncludePaths_ReturnsOriginalQuery()
+    {
+        // Arrange
+        var query = CreateMockQueryable<TestEntity>();
+        var includePaths = new List<string>();
+        var includeFilters = new List<IncludeFilter>();
+
+        // Act
+        var result = query.ApplyFilteredIncludes(includePaths, includeFilters);
+
+        // Assert
+        Assert.Same(query, result);
+    }
+
+    [Fact]
+    public void ApplyFilteredIncludes_WithIncludePathsButNoFilters_AppliesRegularIncludes()
+    {
+        // Arrange
+        var query = CreateMockQueryable<TestEntity>();
+        var includePaths = new List<string> { "comments", "tags" };
+        var includeFilters = new List<IncludeFilter>();
+
+        // Act
+        var result = query.ApplyFilteredIncludes(includePaths, includeFilters);
+
+        // Assert
+        // This would normally test that Include was called, but since we're using a mock
+        // we can't easily verify the EF Core Include calls without a real context
+        Assert.NotNull(result);
+    }
+
+    [Fact]
+    public void ApplyFilteredIncludes_WithSimpleIncludeFilter_BuildsCorrectExpression()
+    {
+        // Arrange
+        var query = CreateMockQueryable<TestEntity>();
+        var includePaths = new List<string> { "comments" };
+        var includeFilters = new List<IncludeFilter>
+        {
+            new()
+            {
+                RelationshipPath = "comments",
+                FieldPath = "status",
+                Filter = new FilterParameter
+                {
+                    Field = "status",
+                    Operator = FilterOperator.Eq,
+                    Value = "approved",
+                },
+            },
+        };
+
+        // Act
+        var result = query.ApplyFilteredIncludes(includePaths, includeFilters);
+
+        // Assert
+        Assert.NotNull(result);
+        // In a real test with EF Core, we would verify the generated SQL contains WHERE clause
+    }
+
+    [Fact]
+    public void ApplyFilteredIncludes_WithMultipleFiltersOnSameRelationship_CombinesFilters()
+    {
+        // Arrange
+        var query = CreateMockQueryable<TestEntity>();
+        var includePaths = new List<string> { "comments" };
+        var includeFilters = new List<IncludeFilter>
+        {
+            new()
+            {
+                RelationshipPath = "comments",
+                FieldPath = "status",
+                Filter = new FilterParameter
+                {
+                    Field = "status",
+                    Operator = FilterOperator.Eq,
+                    Value = "approved",
+                },
+            },
+            new()
+            {
+                RelationshipPath = "comments",
+                FieldPath = "priority",
+                Filter = new FilterParameter
+                {
+                    Field = "priority",
+                    Operator = FilterOperator.Gt,
+                    Value = "5",
+                },
+            },
+        };
+
+        // Act
+        var result = query.ApplyFilteredIncludes(includePaths, includeFilters);
+
+        // Assert
+        Assert.NotNull(result);
+    }
+
+    [Fact]
+    public void ApplyFilteredIncludes_WithNestedIncludePath_HandlesCorrectly()
+    {
+        // Arrange
+        var query = CreateMockQueryable<TestEntity>();
+        var includePaths = new List<string> { "comments.author" };
+        var includeFilters = new List<IncludeFilter>();
+
+        // Act
+        var result = query.ApplyFilteredIncludes(includePaths, includeFilters);
+
+        // Assert
+        Assert.NotNull(result);
+    }
+
+    [Fact]
+    public void ApplyFilteredIncludes_WithMixedFilteredAndUnfilteredIncludes_HandlesCorrectly()
+    {
+        // Arrange
+        var query = CreateMockQueryable<TestEntity>();
+        var includePaths = new List<string> { "comments", "tags", "author" };
+        var includeFilters = new List<IncludeFilter>
+        {
+            new()
+            {
+                RelationshipPath = "comments",
+                FieldPath = "status",
+                Filter = new FilterParameter
+                {
+                    Field = "status",
+                    Operator = FilterOperator.Eq,
+                    Value = "approved",
+                },
+            },
+            // tags and author have no filters
+        };
+
+        // Act
+        var result = query.ApplyFilteredIncludes(includePaths, includeFilters);
+
+        // Assert
+        Assert.NotNull(result);
+    }
+
+    private static IQueryable<T> CreateMockQueryable<T>()
+        where T : class
+    {
+        // Create a minimal mock queryable for testing
+        // In a real scenario, this would be an EF Core DbSet or similar
+        var data = new List<T>().AsQueryable();
+        return data;
+    }
+
+    // Test entity classes for testing
+    public class TestEntity
+    {
+        public int Id { get; set; }
+        public string Title { get; set; } = string.Empty;
+        public string Status { get; set; } = string.Empty;
+        public List<Comment> Comments { get; set; } = new();
+        public List<Tag> Tags { get; set; } = new();
+        public Author? Author { get; set; }
+    }
+
+    public class Comment
+    {
+        public int Id { get; set; }
+        public string Content { get; set; } = string.Empty;
+        public string Status { get; set; } = string.Empty;
+        public int Priority { get; set; }
+        public Author? Author { get; set; }
+        public string? CompanyCode { get; set; }
+    }
+
+    public class Tag
+    {
+        public int Id { get; set; }
+        public string Name { get; set; } = string.Empty;
+    }
+
+    public class Author
+    {
+        public int Id { get; set; }
+        public string Name { get; set; } = string.Empty;
+        public string Department { get; set; } = string.Empty;
+        public string Role { get; set; } = string.Empty;
+    }
+}