SQLite 单元测试中的 FOREIGN KEY 约束失败

Question

I have a database with two different paths to a certain entity, one path with DeleteBehavior.Cascade and the other with DeleteBehavior.Restrict to avoid a multiple cascade paths error on database creation. This is working as I expected when running locally using IIS Express and Visual Studio's SQL Server in memory, but throwing an error in unit tests testing the same functionality.

Example:

public class Account
{
    public string Id { get; set; }
}

Each account can have subscriptions:

public class Subscription
{
    public string Id { get; set; }

    // relationships

    public string AccountId { get; set; }

    public Account Account { get; set; }
}

Both accounts and subscriptions can have contacts (this might not make much sense but it's just an example, in reality my model is more complicated but it essentially boils down to this):

public class Contact
{
    public string Id { get; set; }

    // relationships

    public string AccountId { get; set; }

    public Account Account { get; set; }

    public string SubscriptionId { get; set; }

    public Subscription Subscription { get; set; }
}

I want any contacts to be deleted if either the account or the subscription is deleted. This is my model builder config for contacts:

public void Configure(EntityTypeBuilder<Contact> entity)
{
    entity.HasOne(e => e.Account)
        .WithMany()
        .HasForeignKey(e => e.AccountId)
        .OnDelete(DeleteBehavior.Restrict);

    entity.HasOne(e => e.Subscription)
        .WithMany()
        .HasForeignKey(e => e.SubscriptionId)
        .OnDelete(DeleteBehavior.Cascade);
}

config for subscriptions:

public void Configure(EntityTypeBuilder<Subscription> entity)
{
    entity.HasOne(e => e.Account)
        .WithMany()
        .HasForeignKey(e => e.AccountId)
        .OnDelete(DeleteBehavior.Cascade);
}

The thought being that when an account is deleted this will delete the subscriptions via the Cascade delete behavior, and this will delete the contacts, with the Restrict behavior between accounts and contacts solving the "multiple cascade paths" error.

This works when I'm running locally, I can delete an account and all subscriptions and contacts are deleted, no error. The issue is in the unit tests (using xUnit), which are using SQLite in memory. I want to test that deleting an account will delete all contacts:

[Fact]
public async Task DeleteAccount_ContactIsDeleted()
{
    using (var factory = new ContextFactory()) // same connection will be used within using block
    {
        using (var context = factory.CreateContext())
        {
            await context.SeedDatabaseOneContactAsync(); // inserts account, subscription and contact into database
        }

        using (var context = factory.CreateContext())
        {
            Assert.Single(context.Contacts);
            Assert.Single(context.Subscriptions);
            Assert.Single(context.Accounts);

            var account = await context.Accounts.SingleAsync();
            context.Remove(account);
            await context.SaveChangesAsync();

            Assert.Empty(context.Contacts);
            Assert.Empty(context.Accounts);
            Assert.Empty(context.Subscriptions);
        }
    }
}

However this throws the following error

Message: Microsoft.EntityFrameworkCore.DbUpdateException : An error occurred while updating the entries. See the inner exception for details. ---- Microsoft.Data.Sqlite.SqliteException : SQLite Error 19: 'FOREIGN KEY constraint failed'.

on the line

await context.SaveChangesAsync();

I'd like to know if this is an issue with SQLite, or if there's something I'm doing wrong with my model or config?

Note: I'm using Entity Framework Core 2.1.1, and these relationships are required (can't be nullable).

Answer 1

By default, FK contstraints are disabled in SQLite. http://www.sqlite.org/foreignkeys.html

Foreign key constraints are disabled by default (for backwards compatibility), so must be enabled separately for each database connection. (Note, however, that future releases of SQLite might change so that foreign key constraints enabled by default. Careful developers will not make any assumptions about whether or not foreign keys are enabled by default but will instead enable or disable them as necessary.)

You can enable them with by adding foreign keys=true to your connection string. ( data source=test.db;foreign keys=true for a full example)

Answer 2

Not sure if this is your problem but, I had the same error when the fluent API relationship config did not match the actual table structure.

In my case the fluent API setup a one to one relationship but the actual underlying table structure was a one to many relationship.

Answer 3

Old question but I'm having this same issue.

So far I think it's related to the column being a string which you can't set as a nullable value type. eg. string? if you change it to Guid? or int? then you don't have the same issue.

I think this might be a bug in entity framework where it thinks the column is not nullable when it actually is.