NullableNavigationTests.cs

public class NullableNavigationTests
{
    [Test]
    public async Task Include()
    {
        await using var data = await BuildData(nameof(Include));

        var cars = await data.Cars
            .Include(_ => _.Owner)
            .OrderBy(_ => _.Id)
            .ToListAsync();
        await Verify(cars);
    }

    [Test]
    public async Task IgnoreNavigationProperties()
    {
        await using var data = await BuildData(nameof(IgnoreNavigationProperties));

        var cars = await data.Cars
            .Include(_ => _.Owner)
            .OrderBy(_ => _.Id)
            .ToListAsync();
        await Verify(cars)
            .IgnoreNavigationProperties(data);
    }

    [Test]
    public async Task SuppressNull()
    {
        await using var data = await BuildData(nameof(SuppressNull));

        var cars = await data.Cars
            .Where(_ => _.Owner!.Name == "owner")
            .ToListAsync();
        await Verify(cars);
    }

    [Test]
    public async Task RedundantNullCheck()
    {
        await using var data = await BuildData(nameof(RedundantNullCheck));

        #region RedundantNullCheck

        await ThrowsTask(() =>
                data.Cars
                    .Where(_ => _.Owner != null && _.Owner.Name == "owner")
                    .ToListAsync())
            .IgnoreStackTrace();

        #endregion
    }

    [Test]
    public async Task RedundantNullCheckReversed()
    {
        await using var data = await BuildData(nameof(RedundantNullCheckReversed));

        await Assert.ThrowsExactlyAsync<Exception>(() =>
            data.Cars
                .Where(_ => _.Owner!.Id > 0 && null != _.Owner)
                .ToListAsync());
    }

    // a null Owner matches `!=`, so the check changes the result
    [Test]
    public async Task NullCheckKeptForNotEqual()
    {
        await using var data = await BuildData(nameof(NullCheckKeptForNotEqual));

        var cars = await data.Cars
            .Where(_ => _.Owner != null && _.Owner.Name != "other")
            .ToListAsync();
        await Assert.That(cars).Count().IsEqualTo(1);
    }

    // a null Owner matches when the variable is null, so the check changes the result
    [Test]
    public async Task NullCheckKeptForVariable()
    {
        await using var data = await BuildData(nameof(NullCheckKeptForVariable));

        string? name = null;
        var cars = await data.Cars
            .Where(_ => _.Owner != null && _.Owner.Name == name)
            .ToListAsync();
        await Assert.That(cars).IsEmpty();
    }

    [Test]
    public async Task RedundantNullCheckNullableScalar()
    {
        await using var data = await BuildData(nameof(RedundantNullCheckNullableScalar));

        #region RedundantNullCheckNullableScalar

        await ThrowsTask(() =>
                data.Cars
                    .Where(_ => _.OwnerId != null && _.OwnerId > 0)
                    .ToListAsync())
            .IgnoreStackTrace();

        #endregion
    }

    [Test]
    public async Task RedundantNullCheckHasValue()
    {
        await using var data = await BuildData(nameof(RedundantNullCheckHasValue));
        await ThrowsTask(() =>
                data.Cars
                    .Where(_ => _.OwnerId.HasValue && _.OwnerId.Value == 1)
                    .ToListAsync())
            .IgnoreStackTrace();
    }

    [Test]
    public async Task RedundantNullCheckString()
    {
        await using var data = await BuildData(nameof(RedundantNullCheckString));
        await ThrowsTask(() =>
                data.Cars
                    // ReSharper disable once ConditionIsAlwaysTrueOrFalseAccordingToNullableAPIContract
                    .Where(_ => _.Model != null &&
                                _.Model == "with owner")
                    .ToListAsync())
            .IgnoreStackTrace();
    }

    // a null OwnerId matches `!=`, so the check changes the result
    [Test]
    public async Task NullableScalarCheckKeptForNotEqual()
    {
        await using var data = await BuildData(nameof(NullableScalarCheckKeptForNotEqual));

        var cars = await data.Cars
            .Where(_ => _.OwnerId != null && _.OwnerId != 2)
            .ToListAsync();
        await Assert.That(cars).Count().IsEqualTo(1);
    }

    [Test]
    public async Task RedundantConditionalNullCheck()
    {
        await using var data = await BuildData(nameof(RedundantConditionalNullCheck));

        #region RedundantConditionalNullCheck

        await ThrowsTask(() =>
                data.Cars
                    .OrderBy(_ => _.Owner == null)
                    .ThenBy(_ => _.Owner == null ? null : _.Owner.Name)
                    .ToListAsync())
            .IgnoreStackTrace();

        #endregion
    }

    [Test]
    public async Task RedundantConditionalNullCheckNotEqual()
    {
        await using var data = await BuildData(nameof(RedundantConditionalNullCheckNotEqual));

        await Assert.ThrowsExactlyAsync<Exception>(() =>
            data.Cars
                .Select(_ => _.Owner != null ? _.Owner.Name : null)
                .ToListAsync());
    }

    [Test]
    public async Task RedundantConditionalNullCheckInWhere()
    {
        await using var data = await BuildData(nameof(RedundantConditionalNullCheckInWhere));

        await Assert.ThrowsExactlyAsync<Exception>(() =>
            data.Cars
                .Where(_ => (null == _.Owner ? null : _.Owner.Name) == "owner")
                .ToListAsync());
    }

    // the member is null when the navigation is, so it returns the same values as the conditional
    [Test]
    public async Task ConditionalNullCheckRemoved()
    {
        await using var data = await BuildData(nameof(ConditionalNullCheckRemoved));

        var names = await data.Cars
            .OrderBy(_ => _.Id)
            .Select(_ => _.Owner!.Name)
            .ToListAsync();
        await Assert.That(names).IsEquivalentTo(["owner", null]);
    }

    // a null Owner gives "none", not null, so the check changes the result
    [Test]
    public async Task ConditionalNullCheckKeptForNonNullFallback()
    {
        await using var data = await BuildData(nameof(ConditionalNullCheckKeptForNonNullFallback));

        var names = await data.Cars
            .OrderBy(_ => _.Id)
            .Select(_ => _.Owner == null ? "none" : _.Owner.Name)
            .ToListAsync();
        await Assert.That(names).IsEquivalentTo(["owner", "none"]);
    }

    [Test]
    public async Task RedundantConditionalNullCheckValueType()
    {
        await using var data = await BuildData(nameof(RedundantConditionalNullCheckValueType));

        await ThrowsTask(() =>
                data.Cars
                    .Select(_ => _.Owner == null ? (int?) null : _.Owner.Id)
                    .ToListAsync())
            .IgnoreStackTrace();
    }

    // the converted member is null when the navigation is, so it returns the same values as the conditional
    [Test]
    public async Task ConditionalNullCheckRemovedValueType()
    {
        await using var data = await BuildData(nameof(ConditionalNullCheckRemovedValueType));

        var ids = await data.Cars
            .OrderBy(_ => _.Id)
            .Select(_ => (int?) _.Owner!.Id)
            .ToListAsync();
        await Assert.That(ids).IsEquivalentTo([1, (int?) null]);
    }

    [Test]
    public async Task RedundantConditionalNullCheckHasValue()
    {
        await using var data = await BuildData(nameof(RedundantConditionalNullCheckHasValue));

        await ThrowsTask(() =>
                data.Cars
                    // ReSharper disable once MergeConditionalExpression
                    .Select(_ => _.OwnerId.HasValue ? _.OwnerId.Value : (int?) null)
                    .ToListAsync())
            .IgnoreStackTrace();
    }

    // EF returns an empty collection for a null navigation, with or without the check, so the check never gives null
    [Test]
    public async Task RedundantConditionalNullCheckCollection()
    {
        await using var data = await BuildData(nameof(RedundantConditionalNullCheckCollection));

        await ThrowsTask(() =>
                data.Cars
                    .Select(_ => _.Owner == null ? null : _.Owner.Cars)
                    .ToListAsync())
            .IgnoreStackTrace();
    }

    [Test]
    public async Task ConditionalNullCheckRemovedCollection()
    {
        await using var data = await BuildData(nameof(ConditionalNullCheckRemovedCollection));

        var cars = await data.Cars
            .OrderBy(_ => _.Id)
            .Select(_ => _.Owner!.Cars)
            .ToListAsync();
        await Assert.That(cars[1]).IsEmpty();
    }

    [Test]
    public async Task AllData()
    {
        await using var data = await BuildData(nameof(AllData));

        await Verify(data.AllData())
            .AddExtraSettings(_ => _.TypeNameHandling = TypeNameHandling.Objects);
    }

    static async Task<NullableNavigationDbContext> BuildData(string name)
    {
        var builder = new DbContextOptionsBuilder<NullableNavigationDbContext>();
        builder.UseInMemoryDatabase(nameof(NullableNavigationTests) + name);
        builder.ThrowOnAntiPatterns();
        var data = new NullableNavigationDbContext(builder.Options);

        var owner = new Owner
        {
            Id = 1,
            Name = "owner"
        };
        data.AddRange(
            new Car
            {
                Id = 1,
                Model = "with owner",
                Owner = owner
            },
            new Car
            {
                Id = 2,
                Model = "without owner"
            });
        await data.SaveChangesAsync();
        data.ChangeTracker.Clear();
        return data;
    }

    public class NullableNavigationDbContext(DbContextOptions options) :
        DbContext(options)
    {
        public DbSet<Car> Cars { get; set; } = null!;
        public DbSet<Owner> Owners { get; set; } = null!;
    }

    public class Car
    {
        [DatabaseGenerated(DatabaseGeneratedOption.None)]
        public int Id { get; set; }

        public required string Model { get; set; }
        public int? OwnerId { get; set; }
        public Owner? Owner { get; set; }
    }

    public class Owner
    {
        [DatabaseGenerated(DatabaseGeneratedOption.None)]
        public int Id { get; set; }

        public required string Name { get; set; }
        public List<Car> Cars { get; set; } = [];
    }
}