Início / coding / Perguntas / 79418100
Accepted
rklec
Asked: 2025-02-06 21:27:29 +0800 CST

"Nenhum construtor adequado foi encontrado" mesmo quando eu uso uma classe base como base para teste de unidade parametrizado

  • 772

Quero ter testes parametrizados no NUnit para testes em execução em dois cenários diferentes. A maioria/alguns testes são os mesmos, mas alguns não são. Então pensei, quero ter uma classe base para executar testes comuns em dois cenários.

Aqui está o MVE completo:

using FluentAssertions;
using NUnit.Framework;

public class SystemUnderTest
{
    public bool? CrucialSettingsForSut { get; }

    public SystemUnderTest(bool crucialSettingsForSut)
    {
        // does something with crucialSettingsForSut that inheritly changes the logic, this is just an example
        this.CrucialSettingsForSut = crucialSettingsForSut;
    }
}

public class ConstructorTest
{
    public class BaseTestClass
    {
        protected readonly SystemUnderTest sut;

        public BaseTestClass(bool crucialSettingsForSut)
        {
            this.sut = new SystemUnderTest(crucialSettingsForSut);
        }

        [Test]
        public void TestApplicableToBothCases()
        {
            this.sut.CrucialSettingsForSut.Should().NotBeNull();
        }
    }
    
    [TestFixture]
    public class ActualTestFixtureFalse : BaseTestClass
    {
        public ActualTestFixtureFalse() : base(false) { }

        [Test]
        public void TestOnlyApplyingToFalse()
        {
            this.sut.CrucialSettingsForSut.Should().BeFalse();
        }
    }

    [TestFixture]
    public class ActualTestFixtureTrue : BaseTestClass
    {
        public ActualTestFixtureTrue() : base(true) { }

        [Test]
        public void TestOnlyApplyingToTrue()
        {
            this.sut.CrucialSettingsForSut.Should().BeTrue();
        }
    }
}

Este é um exemplo simplificado, é claro que o código real é mais complexo.

O importante é que TestOnlyApplyingToTruee TestOnlyApplyingToFalsesão contraditórios , ou seja, não posso colocá-los na mesma classe e fazer com que ambos os testes sejam executados em a TestFixturecom o parâmetro para o construtor.

Problema

Infelizmente, o NUnit tenta instanciar BaseTestClassmesmo que eu não queira isso de fato. Afinal, isso contém apenas o conjunto de "testes base":

Isso resulta neste erro para TestApplicableToBothCases:

OneTimeSetUp: No suitable constructor was found
  Exception doesn't have a stacktrace



-----

No suitable constructor was found
  Exception doesn't have a stacktrace

Tentativas

Eu vi No suitable constructor was found em NUnit Parameterised tests , mas no meu caso BaseTestClassdeveria estar lá e tem um propósito, como explicado. Não consigo resolver isso com TestFixture.

Assert.IgnoreUma alternativa pode ser ter um costume TestOnlyApplyingToTruee TestOnlyApplyingToFalsesomente ser acionado se o respectivo outro caso de teste for executado, mas isso é IMHO design de código feio e causa uma entrada de "teste ignorado". A maneira com herança que usei aqui faz muito mais sentido. Além disso, obviamente isso dificilmente escala, pois não tenho apenas um teste para cada cenário como neste exemplo simplificado.

Padrões de design

Você pode se perguntar sobre esse design, mas, na minha humilde opinião, ele é bom para casos simples. Na verdade, ele é apresentado como um padrão de classe de infraestrutura de teste abstrato em The Art of Unit Testing Second Edition (com exemplos em C#) por Roy Osherove . (ISBN: 9781617290893)

O que importa: pelo menos na versão que tenho, eles realmente têm o mesmo erro lá! BaseTestsClass(na Listagem 7.4, página 139) não é abstrato . (Escrevi isso depois de saber a solução.) Simplesmente não importa, porque nenhum teste real está incluído na classe base (não abstrata) ali.

A Listagem 7.6 etc. usa uma classe base abstrata real como solução para esta e, até onde li, também inclui um teste na classe base.

Pergunta

Então, como posso resolver isso da maneira mais elegante?

c#

3 respostas

  1. Se você seguir seu design, você pode fazer a classe de teste base abstract. Isso evitará que o mecanismo de teste NUnit ou os executores de teste tentem instanciar a classe.

    Testei com os executores MsTest e Resharper e parece funcionar bem.

    • 2
  2. Best Answer

    @Klaus deu a resposta correta para o seu caso, mas eu queria explicar com mais detalhes além do que seria possível em um comentário.

    Quando você marca uma classe não abstrata como um teste de fixação, seja explicitamente com [TestFixture]ou implicitamente incluindo testes na classe, você está dizendo ao framework NUnit para instanciá-la e executar esses testes. Claro, isso é impossível sem um construtor apropriado, o que dá origem ao erro.

    OTOH, uma classe abstrata nunca é tratada dessa forma. Ela realmente não é uma TestFixture, meramente uma classe base para seus fixtures de teste reais. "Abstract TestFixture" é o padrão para incluir testes em múltiplos fixtures. Funciona assim...

    1. Crie uma classe abstrata para usar como base. Certifique-se de que ela tenha todos os construtores que você precisa para seu propósito. Não inclua [TestFixture]na base. Se você fizer isso, ainda funcionará, mas o atributo tende a confundir aqueles que leem seu código. Inclua os métodos [Test], [TestCase], etc. na classe base.
    2. Crie quantas classes derivadas precisar. Certifique-se de que cada uma tenha os construtores de que precisa e que cada uma chame o construtor apropriado na classe base. Claro, se a base tiver apenas um construtor padrão, isso acontece automaticamente.

    Às vezes, as pessoas perguntam "Mas o NUnit não poderia simplesmente descobrir tudo isso em vez de dar um erro?" Talvez... mas nós projetamos o framework com a filosofia de que ele tentaria fazer o que você dissesse e daria um erro se isso não fosse possível. Hoje em dia, é mais comum usar analisadores que dão avisos quando você faz algo suspeito, como herdar de um dispositivo de teste não abstrato. O mais recente NUnit.Analyzerspode ter dado algum tipo de aviso neste caso.

    ATUALIZAÇÃO: Como @rklec comentou, não há regra para isso em NUnit.Analyzers. Criei este problema para adicionar uma regra.

    • 2

  3. Como com qualquer outra classe, geralmente é melhor favorecer a composição em vez da herança , então, em vez de derivar da sua classe que contém as coisas comuns, apenas use -a:

    public class ConstructorTest 
{
    public class BaseTestClass
    {
        private readonly SystemUnderTest sut;

        public BaseTestClass(bool crucialSettingsForSut)
        {
            this.sut = new SystemUnderTest(crucialSettingsForSut);
        }

        public void TestApplicableToBothCases()
        {
            this.sut.CrucialSettingsForSut.Should().NotBeNull();
        }
    }
    
    [TestFixture]
    public class ActualTestFixtureFalse
    {
        BaseTestClass baseTest = new BaseTestClass(false);

        [Test]
        public void TestOnlyApplyingToFalse()
        {
            this.sut.CrucialSettingsForSut.Should().BeFalse();
        }
        [Test]
        public void TestApplicableToBothCases()
        {
            this.baseTest.TestApplicableToBothCases(); // call the "base"-class function here
        }
    }

    [TestFixture]
    public class ActualTestFixtureTrue
    {
        BaseTestClass baseTest = new BaseTestClass(true);

        [Test]
        public void TestOnlyApplyingToTrue()
        {
            this.sut.CrucialSettingsForSut.Should().BeTrue();
        }
        
        [Test]
        public void TestApplicableToBothCases()
        {
            this.baseTest.TestApplicableToBothCases(); // call the "base"-class function here
        }
    }
}

    Claro que você está duplicando algumas linhas de código. Mas isso lhe poupa dores de cabeça se o seu BaseTestClasssometime mudar. Por exemplo, quando alguém adiciona uma nova função a ele que não deveria ser usada por todos os testes, você precisaria de alguma forma de desabilitar essa função - e matar o desenvolvedor que introduziu essa nova função.

    • 0

relate perguntas