Validieren von Entitäten mit Datenannotationen oder flüssiger API in EF 7.0 (im Speicher)

Question

Ich kann meine Datenbank in Speicheranbietern nicht überprüfen und testen. zum Beispiel stellte ich diese Eigenschaften erforderlich:

public abstract class Log 
{ 
    #region Properties 
    public Guid Id { get; set; } 
    [Required] 
    public string ClientIp { get; set; } 
    [Required] 
    public string Application { get; set; } 
    [Required] 
    public string Host { get; set; } 
    [Required] 
    public string Path { get; set; } 
    [Required] 
    public string Method { get; set; } 
    [Required] 
    public string User { get; set; } 
    [Required] 
    public string Date { get; set; } 
    #endregion 
} 

und das ist mein DbContext:

public class ApplicationDbContext : IdentityDbContext<ApplicationUsers, Role, Guid>, IUnitOfWork 
{ 
    private readonly IConfigurationRoot _configuration; 

    public ApplicationDbContext(IConfigurationRoot configuration) 
    { 
     _configuration = configuration; 
    } 

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) 
    { 
     var useInMemoryDatabase = _configuration[key: "UseInMemoryDatabase"].Equals(value: "true", 
      comparisonType: StringComparison.OrdinalIgnoreCase); 
     if (useInMemoryDatabase) 
      optionsBuilder.UseInMemoryDatabase(); 
     else 
      optionsBuilder.UseSqlServer(
       connectionString: _configuration[key: "ConnectionStrings:ApplicationDbContextConnection"] 
       , sqlServerOptionsAction: serverDbContextOptionsBuilder => 
       { 
        var minutes = (int) TimeSpan.FromMinutes(3).TotalSeconds; 
        serverDbContextOptionsBuilder.CommandTimeout(commandTimeout: minutes); 
       }); 
    } 

    protected override void OnModelCreating(ModelBuilder modelBuilder) 
    { 
     base.OnModelCreating(modelBuilder); 

     modelBuilder.Entity<Log>() 
      .HasKey(c => c.Id); 
     modelBuilder.Entity<Log>() 
      .HasDiscriminator<int>(name: "Type") 
      .HasValue<LogRequest>(value: Convert.ToInt32(value: LogLevel.Information)) 
      .HasValue<LogError>(value: Convert.ToInt32(value: LogLevel.Error)); 


    } 

Und das ist mein Unit-Test:

[TestClass] 
public class LogRepositoryTest 
{ 


    private readonly IServiceProvider _serviceProvider; 
    public LogRepositoryTest() 
    { 
     var services = new ServiceCollection(); 
     services.AddScoped<IUnitOfWork, ApplicationDbContext>(); 
     services.AddScoped<ILogRepository, LogRepository>(); 
     services.AddSingleton(provider => new ConfigurationBuilder() 
      .AddInMemoryCollection(initialData: new[] 
      { 
       new KeyValuePair<string, string>(key: "UseInMemoryDatabase", value: "true"), 

      }) 
      .Build()); 
     services.AddEntityFrameworkInMemoryDatabase().AddDbContext<ApplicationDbContext>(ServiceLifetime.Scoped); 
     _serviceProvider = services.BuildServiceProvider(); 
    } 
    [TestMethod] 
    public async Task Verify_SaveRequestLog() 
    { 
     using (var serviceScope = _serviceProvider.GetRequiredService<IServiceScopeFactory>().CreateScope()) 
     { 
      using (var context = serviceScope.ServiceProvider.GetRequiredService<IUnitOfWork>()) 
      { 
       context.Set<Log>().Add(new LogRequest()); 
       var result =await context.SaveAllChangesAsync(); 
       Assert.AreEqual(1, result); 
      } 

     } 
    } 

Aber die Einheit Testmethode immer gibt 1 zurück und übergibt, während das leere Objekt von LogRequest nichts in der Datenbank speichern darf! Wie kann ich Nicht-Null-Eigenschaften für Komponententest ermitteln? In der Tat, wie kann ich Einheitentest erzwingen, um Gültigkeitsrichtlinien zu reflektieren?

Update:

auf diesem Linkes Basierend: Entity Framework Core Issues

, dass ich fragte ich diese respond bekam:

EF-Core tut keine Validierung von Entitäten jenseits dem, was wird benötigt für die interne Konsistenz. Validierung ist etwas, das in EF gemacht werden könnte, aber die Erfahrung zeigt, dass es nicht nützlich für viele Entwickler ist, weil es in der Regel keine clientseitige Validierung oder Validierung der Datenbank ersetzen kann und es gibt auch andere Orte wo Validierung effektiver gemacht werden.

Über die EF hinaus in die Datenbank hinaus überprüft die In-Memory-Datenbank derzeit nicht die Zulässigkeit (d. H. Erforderlichkeit) beim Speichern von Eigenschaftswerten. Ich werde dieses Problem offen lassen, so dass wir als ein Team besprechen können, ob das etwas ist, das wir hinzufügen sollten.

Wenn der Intent-Test mit einer In-Memory-Datenbank als Approximation für eine relationale Datenbank durchgeführt wird, möchten Sie möglicherweise die Verwendung von SQLite im In-Memory-Modus mit in Erwägung ziehen. Weitere Informationen finden Sie unter https://docs.microsoft.com/en-us/ef/core/miscellaneous/testing/index .

Answer 1

auf diesem Linkes Basierend: Entity Framework Core Issues

, dass ich fragte, bekam ich meine Antwort:

class MyContext : DbContext 
{ 
public override int SaveChanges() 
{ 
    var entities = from e in ChangeTracker.Entries() 
        where e.State == EntityState.Added 
         || e.State == EntityState.Modified 
        select e.Entity; 
    foreach (var entity in entities) 
    { 
     var validationContext = new ValidationContext(entity); 
     Validator.ValidateObject(entity, validationContext); 
    } 

    return base.SaveChanges(); 
} 
}