Here's a demo system based on your code. I've made up Account as you didn't provide it and I've created a demo in-memory database to test against.

Account

public record Account
{
    public string? Name { get; init; }
    public int AccountId { get; init; }
    public Guid UserId { get; init; }
    public string? Email { get; init; }
}

The DbContext

public sealed class InMemoryTestDbContext
    : DbContext
{
    public DbSet<Account> Accounts { get; set; } = default!;
 
    public InMemoryTestDbContext(DbContextOptions<InMemoryTestDbContext> options) : base(options) { }
}

The Test DataProvider

public sealed class TestDataProvider
{
    public static IEnumerable<Account> Accounts => _accounts;

    private static List<Account> _accounts = new()
    {
        new() { UserId=Guid.Parse("10000000-0000-0000-0000-000000000001"), Name="Visitor", AccountId=1, Email="me@you.com"},
    };

    public static void LoadDbContext<TDbContext>(IDbContextFactory<TDbContext> factory) where TDbContext : DbContext
    {
        using var dbContext = factory.CreateDbContext();

        var accounts = dbContext.Set<Account>();

        // Check if we already have a data set
        // If not add the data set
        if (accounts.Count() == 0)
        {
            dbContext.AddRange(Accounts);
            dbContext.SaveChanges();
        }
    }
}

AccountHandler

This is your code encapsulated within a handler that you register in DI. Note there's no try as you don't need one.

I've taken the liberty of refactoring your code and changing the EF interaction to async behaviour.

public class AccountHandler
{
    private readonly IDbContextFactory<InMemoryTestDbContext> _dbContextFactory;
    private Account? _account;

    public AccountHandler(IDbContextFactory<InMemoryTestDbContext> dbContextFactory)
        => _dbContextFactory = dbContextFactory;

    public async ValueTask<Account?> GetAccountAsync(string? accountID)
    {
        _account = null;

        if (accountID is null)
            return null;

        if (await TryGetGuidAccountAsync(accountID))
            return _account;

        if (await TryGetIntAccountAsync(accountID))
            return _account;

        if (await TryGetEmailAccountAsync(accountID))
            return _account;

        return null;
    }

    private async ValueTask<bool> TryGetGuidAccountAsync(string accountID)
    {
        if (Guid.TryParse(accountID, out Guid accountId))
        {
            using var context = _dbContextFactory.CreateDbContext();
            _account = await context.Accounts.FirstOrDefaultAsync(c => c.UserId.Equals(accountId));

            return _account is not null;
        }
        return false;
    }

    private async ValueTask<bool> TryGetIntAccountAsync(string accountID)
    {
        if (int.TryParse(accountID, out int id))
        {
            using var context = _dbContextFactory.CreateDbContext();
            _account = await context.Accounts.FirstOrDefaultAsync(a => a.AccountId.Equals(id));

            return _account is not null;
        }
        return false;
    }

    private async ValueTask<bool> TryGetEmailAccountAsync(string accountID)
    {
        // simplified logic to demo
        if (accountID.Contains("@"))
        {
            using var context = _dbContextFactory.CreateDbContext();
            _account = await context.Accounts.FirstOrDefaultAsync(a => accountID.Equals(a.Email));

            return _account is not null;
        }

        return false;
    }
}

The following XUnit test class tests the pipeline.

public class AccountHandlerTests
{
    private ServiceProvider GetServiceProvider()
    {
        // Creates a DI Service collection
        var services = new ServiceCollection();

        //Adds the required services
        services.AddDbContextFactory<InMemoryTestDbContext>(options
            => options.UseInMemoryDatabase($"TestDatabase-{Guid.NewGuid().ToString()}"));
        services.AddTransient<AccountHandler>();
        services.AddLogging(builder => builder.AddDebug());

        // Builds the provider
        var provider = services.BuildServiceProvider();

        // get the DbContext factory and add the test data
        var factory = provider.GetService<IDbContextFactory<InMemoryTestDbContext>>();
        if (factory is not null)
            TestDataProvider.LoadDbContext<InMemoryTestDbContext>(factory);

        return provider!;
    }

    [Fact]
    public async Task TestAccountHandlerGuid()
    {
        var serviceProvider = GetServiceProvider();
        var handler = serviceProvider.GetService<AccountHandler>()!;

        var account = await handler.GetAccountAsync("10000000-0000-0000-0000-000000000001");

        Assert.NotNull(account);
        Assert.Equal("Visitor", account.Name);
    }

    [Fact]
    public async Task TestAccountHandlerInt()
    {
        var serviceProvider = GetServiceProvider();
        var handler = serviceProvider.GetService<AccountHandler>()!;

        var account = await handler.GetAccountAsync("1");

        Assert.NotNull(account);
        Assert.Equal("Visitor", account.Name);
    }

    [Fact]
    public async Task TestAccountHandlerEmail()
    {
        var serviceProvider = GetServiceProvider();
        var handler = serviceProvider.GetService<AccountHandler>()!;

        var account = await handler.GetAccountAsync("me@you.com");

        Assert.NotNull(account);
        Assert.Equal("Visitor", account.Name);
    }

    [Fact]
    public async Task Test1000Times()
    {
        var serviceProvider = GetServiceProvider();

        var counter = 0;
        for (var i = 0; i < 1000; i++)
        {
            {
                var handler = serviceProvider.GetService<AccountHandler>()!;

                var account = await handler.GetAccountAsync("10000000-0000-0000-0000-000000000001");

                Assert.NotNull(account);
                Assert.Equal("Visitor", account.Name);

            }
            {
                var handler = serviceProvider.GetService<AccountHandler>()!;

                var account = await handler.GetAccountAsync("1");

                Assert.NotNull(account);
                Assert.Equal("Visitor", account.Name);
            }
            {
                var handler = serviceProvider.GetService<AccountHandler>()!;

                var account = await handler.GetAccountAsync("me@you.com");

                Assert.NotNull(account);
                Assert.Equal("Visitor", account.Name);
            }

            counter++;
        }

        Assert.Equal(1000, counter);
    }
}

You are learning a painful lesson is application design.

If your only way of testing the problem is to do page refreshes then you have serious design problems, and need to structure your application so you can both end-to-end and unit test it.

To do this you need to apply some sort of structured design principles where you break you code out into a set of design domains with clean interfaces between the domains.

To give you an idea this is what I do.

I base my solutions on "Clean Design" principles and have three domains:

1. The Core Domain contains all my business logic and data classes.
2. The Infrastructure Domain contains all the code that interfaces to data stores and third party systems.
3. The Presentation Domain contains all the UI code.

I use projects within my VS solution with clearly defined dependancies. Presentation depends on Core, Infrastructure depends on Core.

I can then write XUnit tests that run whatever tests I want to test individual sections of my data pipeline or from a specific point backwards to the data store. I can create tests that will open and close a DbContext say a thousand times at various points, and therefore isolate which bit is the root cause of the problem.

I can also write BUnit tests to do the same with Blazor Components.