Add and expand EFCore multitenancy test coverage

Introduces new unit tests for EFCore multitenancy features, including options, dependency injection, entity configuration, metadata, migration runner, model cache key factory, model customizer, and save changes interceptor. Updates test project dependencies to include EFCore.Relational and EFCore.Sqlite. Adds InternalsVisibleTo attribute for test assembly access.

Author: mheidari988

src/CleanArchitecture.Extensions.Multitenancy.EFCore/AssemblyInfo.cs

@@ -0,0 +1,3 @@
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("CleanArchitecture.Extensions.Multitenancy.EFCore.Tests")]

tests/CleanArchitecture.Extensions.Multitenancy.EFCore.Tests/CleanArchitecture.Extensions.Multitenancy.EFCore.Tests.csproj

@@ -16,6 +16,8 @@
     </PackageReference>
     <PackageReference Include="Microsoft.EntityFrameworkCore" Version="10.0.0" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="10.0.0" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Relational" Version="10.0.0" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="10.0.0" />
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="10.0.0" />
     <PackageReference Include="Microsoft.Extensions.Options" Version="10.0.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.0.1" />

tests/CleanArchitecture.Extensions.Multitenancy.EFCore.Tests/DefaultTenantConnectionResolverTests.cs

@@ -0,0 +1,38 @@
+using CleanArchitecture.Extensions.Multitenancy;
+using CleanArchitecture.Extensions.Multitenancy.EFCore.Factories;
+using CleanArchitecture.Extensions.Multitenancy.EFCore.Options;
+
+namespace CleanArchitecture.Extensions.Multitenancy.EFCore.Tests;
+
+public class DefaultTenantConnectionResolverTests
+{
+    [Fact]
+    public void ResolveConnectionString_uses_format_from_options()
+    {
+        var options = new EfCoreMultitenancyOptions
+        {
+            ConnectionStringFormat = "Server={0};"
+        };
+
+        var resolver = new DefaultTenantConnectionResolver(Microsoft.Extensions.Options.Options.Create(options));
+
+        var connectionString = resolver.ResolveConnectionString(new TenantInfo("alpha"));
+
+        Assert.Equal("Server=alpha;", connectionString);
+    }
+
+    [Fact]
+    public void ResolveConnectionString_uses_provider_from_options()
+    {
+        var options = new EfCoreMultitenancyOptions
+        {
+            ConnectionStringProvider = _ => "provider"
+        };
+
+        var resolver = new DefaultTenantConnectionResolver(Microsoft.Extensions.Options.Options.Create(options));
+
+        var connectionString = resolver.ResolveConnectionString(new TenantInfo("alpha"));
+
+        Assert.Equal("provider", connectionString);
+    }
+}

tests/CleanArchitecture.Extensions.Multitenancy.EFCore.Tests/DependencyInjectionExtensionsTests.cs

@@ -0,0 +1,36 @@
+using CleanArchitecture.Extensions.Multitenancy.EFCore.Abstractions;
+using CleanArchitecture.Extensions.Multitenancy.EFCore.Interceptors;
+using CleanArchitecture.Extensions.Multitenancy.EFCore.Migrations;
+using Microsoft.EntityFrameworkCore.Diagnostics;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+
+namespace CleanArchitecture.Extensions.Multitenancy.EFCore.Tests;
+
+public class DependencyInjectionExtensionsTests
+{
+    [Fact]
+    public void AddCleanArchitectureMultitenancyEfCore_registers_services()
+    {
+        var services = new ServiceCollection();
+
+        services.AddCleanArchitectureMultitenancyEfCore();
+
+        Assert.Contains(services, descriptor => descriptor.ServiceType == typeof(ITenantModelCustomizer));
+        Assert.Contains(services, descriptor => descriptor.ServiceType == typeof(ITenantConnectionResolver));
+        Assert.Contains(services, descriptor => descriptor.ServiceType == typeof(IModelCacheKeyFactory));
+        Assert.Contains(services, descriptor => descriptor.ServiceType == typeof(TenantSaveChangesInterceptor));
+        Assert.Contains(services, descriptor => descriptor.ServiceType == typeof(ISaveChangesInterceptor));
+    }
+
+    [Fact]
+    public void AddTenantDbContextFactory_registers_factory_and_runner()
+    {
+        var services = new ServiceCollection();
+
+        services.AddTenantDbContextFactory<TestDbContext>();
+
+        Assert.Contains(services, descriptor => descriptor.ServiceType == typeof(ITenantDbContextFactory<TestDbContext>));
+        Assert.Contains(services, descriptor => descriptor.ServiceType == typeof(TenantMigrationRunner<TestDbContext>));
+    }
+}

tests/CleanArchitecture.Extensions.Multitenancy.EFCore.Tests/EfCoreMultitenancyOptionsTests.cs

@@ -0,0 +1,99 @@
+using CleanArchitecture.Extensions.Multitenancy;
+using CleanArchitecture.Extensions.Multitenancy.EFCore.Options;
+
+namespace CleanArchitecture.Extensions.Multitenancy.EFCore.Tests;
+
+public class EfCoreMultitenancyOptionsTests
+{
+    [Fact]
+    public void ResolveSchemaName_uses_provider_when_configured()
+    {
+        var options = new EfCoreMultitenancyOptions
+        {
+            SchemaNameProvider = _ => "custom"
+        };
+
+        var schema = options.ResolveSchemaName(new TenantInfo("alpha"));
+
+        Assert.Equal("custom", schema);
+    }
+
+    [Fact]
+    public void ResolveSchemaName_uses_default_schema_for_null_tenant()
+    {
+        var options = new EfCoreMultitenancyOptions
+        {
+            DefaultSchema = "default"
+        };
+
+        var schema = options.ResolveSchemaName(null);
+
+        Assert.Equal("default", schema);
+    }
+
+    [Fact]
+    public void ResolveSchemaName_formats_schema_for_tenant()
+    {
+        var options = new EfCoreMultitenancyOptions
+        {
+            SchemaNameFormat = "tenant_{0}"
+        };
+
+        var schema = options.ResolveSchemaName(new TenantInfo("alpha"));
+
+        Assert.Equal("tenant_alpha", schema);
+    }
+
+    [Fact]
+    public void ResolveSchemaName_falls_back_to_default_when_format_missing()
+    {
+        var options = new EfCoreMultitenancyOptions
+        {
+            SchemaNameFormat = string.Empty,
+            DefaultSchema = "fallback"
+        };
+
+        var schema = options.ResolveSchemaName(new TenantInfo("alpha"));
+
+        Assert.Equal("fallback", schema);
+    }
+
+    [Fact]
+    public void ResolveConnectionString_uses_provider_when_configured()
+    {
+        var options = new EfCoreMultitenancyOptions
+        {
+            ConnectionStringProvider = _ => "provider"
+        };
+
+        var connectionString = options.ResolveConnectionString(new TenantInfo("alpha"));
+
+        Assert.Equal("provider", connectionString);
+    }
+
+    [Fact]
+    public void ResolveConnectionString_formats_string_for_tenant()
+    {
+        var options = new EfCoreMultitenancyOptions
+        {
+            ConnectionStringFormat = "Server={0};"
+        };
+
+        var connectionString = options.ResolveConnectionString(new TenantInfo("alpha"));
+
+        Assert.Equal("Server=alpha;", connectionString);
+    }
+
+    [Fact]
+    public void ResolveConnectionString_returns_null_for_missing_tenant()
+    {
+        var options = new EfCoreMultitenancyOptions
+        {
+            ConnectionStringFormat = "Server={0};"
+        };
+
+        var connectionString = options.ResolveConnectionString(null);
+
+        Assert.Null(connectionString);
+    }
+}

tests/CleanArchitecture.Extensions.Multitenancy.EFCore.Tests/TenantEntityConfigurationTests.cs

@@ -0,0 +1,96 @@
+using CleanArchitecture.Extensions.Multitenancy.EFCore.Abstractions;
+using Microsoft.EntityFrameworkCore;
+
+namespace CleanArchitecture.Extensions.Multitenancy.EFCore.Tests;
+
+public class TenantEntityConfigurationTests
+{
+    [Fact]
+    public void Configure_adds_required_tenant_id_for_tenant_entities()
+    {
+        using var dbContext = new ConfigurationDbContext(CreateOptions());
+        var entityType = dbContext.Model.FindEntityType(typeof(ConfigTenantEntity));
+
+        Assert.NotNull(entityType);
+
+        var property = entityType!.FindProperty("TenantId");
+
+        Assert.NotNull(property);
+        Assert.False(property!.IsNullable);
+    }
+
+    [Fact]
+    public void Configure_adds_shadow_tenant_id_for_plain_entities()
+    {
+        using var dbContext = new ConfigurationDbContext(CreateOptions());
+        var entityType = dbContext.Model.FindEntityType(typeof(ConfigPlainEntity));
+
+        Assert.NotNull(entityType);
+
+        var property = entityType!.FindProperty("TenantId");
+
+        Assert.NotNull(property);
+        Assert.True(property!.IsShadowProperty());
+    }
+
+    [Fact]
+    public void Configure_skips_tenant_id_for_global_entities()
+    {
+        using var dbContext = new ConfigurationDbContext(CreateOptions());
+        var entityType = dbContext.Model.FindEntityType(typeof(ConfigGlobalEntity));
+
+        Assert.NotNull(entityType);
+
+        var property = entityType!.FindProperty("TenantId");
+
+        Assert.Null(property);
+    }
+
+    private static DbContextOptions<ConfigurationDbContext> CreateOptions()
+        => new DbContextOptionsBuilder<ConfigurationDbContext>()
+            .UseInMemoryDatabase(Guid.NewGuid().ToString())
+            .Options;
+
+    private sealed class ConfigurationDbContext : DbContext
+    {
+        public ConfigurationDbContext(DbContextOptions<ConfigurationDbContext> options)
+            : base(options)
+        {
+        }
+
+        protected override void OnModelCreating(ModelBuilder modelBuilder)
+        {
+            modelBuilder.ApplyConfiguration(new ConfigTenantEntityConfiguration());
+            modelBuilder.ApplyConfiguration(new ConfigPlainEntityConfiguration());
+            modelBuilder.ApplyConfiguration(new ConfigGlobalEntityConfiguration());
+        }
+    }
+
+    private sealed class ConfigTenantEntityConfiguration : TenantEntityConfiguration<ConfigTenantEntity>
+    {
+    }
+
+    private sealed class ConfigPlainEntityConfiguration : TenantEntityConfiguration<ConfigPlainEntity>
+    {
+    }
+
+    private sealed class ConfigGlobalEntityConfiguration : TenantEntityConfiguration<ConfigGlobalEntity>
+    {
+    }
+
+    private sealed class ConfigTenantEntity : ITenantEntity
+    {
+        public int Id { get; set; }
+        public string TenantId { get; set; } = string.Empty;
+    }
+
+    private sealed class ConfigPlainEntity
+    {
+        public int Id { get; set; }
+    }
+
+    private sealed class ConfigGlobalEntity : IGlobalEntity
+    {
+        public int Id { get; set; }
+    }
+}