Added web module tests

tests/HopFrame.Tests.Core/Models/MockDbContext.cs

@@ -0,0 +1,13 @@
+using Microsoft.EntityFrameworkCore;
+
+namespace HopFrame.Tests.Core.Models;
+
+// A mock DbContext for testing purposes
+public class MockDbContext : DbContext {
+    public DbSet<MockModel> Models { get; set; }
+    public DbSet<MockModel2> Models2 { get; set; }
+
+    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) {
+        optionsBuilder.UseInMemoryDatabase(nameof(MockDbContext));
+    }
+}

tests/HopFrame.Tests.Core/Models/MockModel.cs

@@ -0,0 +1,12 @@
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace HopFrame.Tests.Core.Models;
+
+// A mock model for testing purposes
+public class MockModel {
+    public int Id { get; set; }
+    public string? Name { get; set; }
+    
+    [ForeignKey("other")] 
+    public List<MockModel2> Model2 { get; set; }
+}

tests/HopFrame.Tests.Core/Models/MockModel2.cs

@@ -0,0 +1,12 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace HopFrame.Tests.Core.Models;
+
+public class MockModel2 {
+    [Key] 
+    public required string Id { get; set; }
+
+    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
+    public int Number { get; set; }
+}

tests/HopFrame.Tests.Core/Models/QueryProvider.cs

@@ -0,0 +1,129 @@
+using System.Linq.Expressions;
+using Microsoft.EntityFrameworkCore.Query;
+
+namespace HopFrame.Tests.Core.Models;
+
+// A mock implementation for async query provider
+internal class TestAsyncQueryProvider<TEntity> : IAsyncQueryProvider {
+    private readonly IQueryProvider _inner;
+
+    internal TestAsyncQueryProvider(IQueryProvider inner) {
+        _inner = inner;
+    }
+
+    public IQueryable CreateQuery(Expression expression) {
+        return new TestAsyncEnumerable<TEntity>(expression);
+    }
+
+    public IQueryable<TElement> CreateQuery<TElement>(Expression expression) {
+        return new TestAsyncEnumerable<TElement>(expression);
+    }
+
+    public object Execute(Expression expression) {
+        return _inner.Execute(expression);
+    }
+
+    public TResult Execute<TResult>(Expression expression) {
+        return _inner.Execute<TResult>(expression);
+    }
+
+    public TResult ExecuteAsync<TResult>(Expression expression,
+        CancellationToken cancellationToken = new CancellationToken()) {
+        return _inner.Execute<TResult>(expression);
+    }
+
+    public IAsyncEnumerable<TResult> ExecuteAsync<TResult>(Expression expression) {
+        return new TestAsyncEnumerable<TResult>(expression);
+    }
+}
+
+internal class TestAsyncEnumerable<T> : EnumerableQuery<T>, IAsyncEnumerable<T>, IQueryable<T> {
+    public TestAsyncEnumerable(IEnumerable<T> enumerable) : base(enumerable) { }
+
+    public TestAsyncEnumerable(Expression expression) : base(expression) { }
+
+    public IAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default) {
+        return new TestAsyncEnumerator<T>(this.AsEnumerable().GetEnumerator());
+    }
+
+    IQueryProvider IQueryable.Provider => new TestAsyncQueryProvider<T>(this);
+}
+
+internal class TestAsyncEnumerator<T> : IAsyncEnumerator<T> {
+    private readonly IEnumerator<T> _inner;
+
+    public TestAsyncEnumerator(IEnumerator<T> inner) {
+        _inner = inner ?? throw new ArgumentNullException(nameof(inner));
+    }
+
+    public T Current => _inner.Current;
+
+    public ValueTask DisposeAsync() {
+        _inner.Dispose();
+        return new ValueTask();
+    }
+
+    public ValueTask<bool> MoveNextAsync() {
+        return new ValueTask<bool>(_inner.MoveNext());
+    }
+}
+
+/*// A mock implementation for async query provider
+internal class TestAsyncQueryProvider<TEntity> : IAsyncQueryProvider {
+    private readonly IQueryProvider _inner;
+
+    internal TestAsyncQueryProvider(IQueryProvider inner) {
+        _inner = inner;
+    }
+
+    public IQueryable CreateQuery(Expression expression) {
+        return new TestAsyncEnumerable<TEntity>(expression);
+    }
+
+    public IQueryable<TElement> CreateQuery<TElement>(Expression expression) {
+        return new TestAsyncEnumerable<TElement>(expression);
+    }
+
+    public object? Execute(Expression expression) {
+        return _inner.Execute(expression);
+    }
+
+    public TResult Execute<TResult>(Expression expression) {
+        return _inner.Execute<TResult>(expression);
+    }
+
+    public TResult ExecuteAsync<TResult>(Expression expression, CancellationToken cancellationToken) {
+        return _inner.Execute<TResult>(expression);
+    }
+
+    public IAsyncEnumerable<TResult> ExecuteAsync<TResult>(Expression expression) {
+        return new TestAsyncEnumerable<TResult>(expression);
+    }
+}
+
+internal class TestAsyncEnumerable<T> : EnumerableQuery<T>, IAsyncEnumerable<T>, IQueryable<T> {
+    public TestAsyncEnumerable(IEnumerable<T> enumerable) : base(enumerable) { }
+
+    public TestAsyncEnumerable(Expression expression) : base(expression) { }
+
+    public IAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default) {
+        return new TestAsyncEnumerator<T>(this.AsEnumerable().GetEnumerator());
+    }
+
+    IQueryProvider IQueryable.Provider => new TestAsyncQueryProvider<T>(this);
+}
+
+internal class TestAsyncEnumerator<T>(IEnumerator<T> inner) : IAsyncEnumerator<T> {
+    private readonly IEnumerator<T> _inner = inner ?? throw new ArgumentNullException(nameof(inner));
+
+    public T Current => _inner.Current;
+
+    public ValueTask DisposeAsync() {
+        _inner.Dispose();
+        return new ValueTask();
+    }
+
+    public ValueTask<bool> MoveNextAsync() {
+        return new ValueTask<bool>(_inner.MoveNext());
+    }
+}*/