Unit test di una classe template dopo il refactoring

Sto ripulendo il mio codice rimuovendo i duplicati e ho trovato due classi quasi identiche, su 55 righe, solo un singolo predicato in un'istruzione if differiva tra loro.

Entrambe le classi avevano anche una serie di test, che erano copie quasi identiche.

Le due classi originali erano FooApiAuthenticationProvider e BarApiAuthenticationProvider .

Di seguito è riportato il mio codice refactored corrente che utilizza un refactoring con modello di modello.

modello

public abstract class ApiAuthenticationProviderTemplate : IApiAuthenticationProvider
{
    private readonly IClientRepository _clientRepository;

    protected ApiAuthenticationProviderTemplate(IClientRepository clientRepository)
    {
        if (clientRepository == null)
        {
            throw new ArgumentNullException("clientRepository");
        }

        _clientRepository = clientRepository;
    }

    public GenericPrincipal GetPrincipal(string username, string password)
    {
        if (string.IsNullOrWhiteSpace(username))
        {
            throw new ArgumentNullException("username");
        }

        if (string.IsNullOrWhiteSpace(password))
        {
            throw new ArgumentNullException("password");
        }

        var client = clientRepository.GetByUsername(username);

        if (client == null && !DoesPasswordMatch(password, client))
        {
            return null;
        }

        return PrincipalBuilder.BuildPrinciple(client.LoginIdentifier, client.ID);
    }

    protected abstract bool DoesPasswordMatch(string password, Client client);
}

FooApiAuthenticationProvider

public sealed class FooApiAuthenticationProvider : ApiAuthenticationProviderTemplate
{
    public FooApiAuthenticationProvider(IClientRepository clientRepository)
        : base(clientRepostitory)
    {
    }

    protected override bool DoesPasswordMatch(string password, Client client)
    {
        return client.FooApiPassword == password;
    }
}

BarApiAuthenticationProvider

public sealed class BarApiAuthenticationProvider : ApiAuthenticationProviderTemplate
{
    public BarApiAuthenticationProvider(IClientRepository clientRepository)
        : base(clientRepostitory)
    {
    }   

    protected override bool DoesPasswordMatch(string password, Client client)
    {
        return client.DoesBarServicePasswordMatch(password);
    }   
}

Entrambe le unità di test di prova per ogni passaggio di classe specifico, e normalmente quella sarebbe la fine del pensiero, tuttavia, devo estendere la funzionalità che è comune a entrambi i provider di autenticazione (quindi ovviamente implementerei nella classe base del modello) .

Le mie domande sono:

1. Devo refactoring il codice di prova per rimuovere la duplicazione del test? Per testare la classe astratta in qualche modo e scrivere test specifici per il metodo DoesPasswordMatch

2. Devo aggiungere nuovi test a entrambi per garantire che i tipi effettivi funzionino entrambi correttamente? Il che significa che i test non dovrebbero avere alcuna idea che la classe sottostante sia un modello, in questo modo se entrambi i provider diventano significativamente diversi nei casi in cui il modello non ha più senso, potrebbe essere cancellato via senza perdere la copertura del codice.

3. Devo lasciare entrambi gli apparecchi di prova uguali e scrivere semplicemente un nuovo dispositivo con test sul modello per la nuova funzionalità?

4. C'è qualcos'altro che non sto considerando?