XUnit: Eseguire tutte Assert'ions' in un unico metodo di prova?

Question

E 'possibile dire xUnit.net di eseguire tutti per esempio Assert.True() in un metodo? Sostanzialmente le nostre utilizzo / testcases tutte le asserzioni appartengono logicamente uno stesso 'ambito' di test e ho es qualcosa di simile a questo:

    [Fact(DisplayName = "Tr-MissImpl")]
    public void MissingImplementationTest()
    {
        // parse export.xml file
        var exportXml = Libraries.Utilities.XML.GenericClassDeserializer.DeserializeXmlFile<Libraries.MedTrace.ExportXml>(
                ExportXmlFile);

        // compare parsed results with expected ones
        Assert.True(exportXml.ContainsRequirementKeyWithError("PERS_154163", "E0032A"));
        Assert.True(exportXml.ContainsRequirementKeyWithError("PERS_155763", "E0032A"));
        Assert.True(exportXml.ContainsRequirementKeyWithError("PERS_155931", "E0032A"));
        Assert.True(exportXml.ContainsRequirementKeyWithError("PERS_157145", "E0032A"));

        Assert.True(exportXml.ContainsRequirementKeyWithError("s_sw_ers_req_A", "E0032A"));
        Assert.True(exportXml.ContainsRequirementKeyWithError("s_sw_ers_req_C", "E0032A"));
        Assert.True(exportXml.ContainsRequirementKeyWithError("s_sw_ers_req_D", "E0032A"));       
    }

Ora, se per esempio il primo Assert.True(...) fallisce, le altre non vengono eseguiti / controllati. Preferirei non rompere questi sette asserzioni fino in metodi separati, dal momento che questi in realtà appartengono insieme logicamente (TC è soltanto 'superato' tutto se tutti e sette stanno passando tutti insieme).

Answer 1

Il punto di AAA è quello di mirare a semplificare ogni pezzo, per quanto possibile e tenerlo concentrato, così i lettori possono capire i test in modo rapido ed isolare la causa di guasti facilmente.

Avete 7 Facts diversi, che insieme comprendono un Theory. Quindi è necessario creare un [Theory] con 7 gruppi di [InlineData] che rappresentano le aspettative. Vedere http://blog.benhall.me.uk /2008/01/introduction-to-xunitnet-extensions.html per un esempio.

Se la ri-esecuzione di Arrange / Act è un problema, allora si dovrebbe fare che il 'dispositivo' (in xUnit Prova Patterns gergo) di farlo nel costruttore della classe di test.

public class WithGenericClassDeserializer
{
    var exportXml;

    public WithGenericClassDeserializer()
    {
        // Or move this into the GivenExportXmlFile_ExpectedValueAtKeyShouldMatch
        exportXml = Libraries.Utilities.XML.GenericClassDeserializer.DeserializeXmlFile<Libraries.MedTrace.ExportXml>( ExportXmlFile );
    }

    [Theory( DisplayName = "Tr-MissImpl" )]
    [InlineData( "PERS_154163", "E0032A" )]
    [InlineData( "PERS_155763", "E0032A" )]
    [InlineData( "PERS_155931", "E0032A" )]
    [InlineData( "PERS_157145", "E0032A" )]
    [InlineData( "s_sw_ers_req_A", "E0032A" )]
    [InlineData( "s_sw_ers_req_C", "E0032A" )]
    [InlineData( "s_sw_ers_req_D", "E0032A" )]
    public void GivenExportXmlFile_ExpectedValueAtKeyShouldMatch( string key, string value )
    {
        Assert.True( exportXml.ContainsRequirementKeyWithError( key, value ) );
    }
}

Answer 2

Sì, è possibile, ma bisogna aggiungere il codice in più per il test. Ogni istruzione Assert in xUnit sarà un'eccezione se l'asserzione fallisce. Quindi, nel caso di Assert.True si getta una TrueException. Allora, cosa si potrebbe fare è qualcosa sulla falsariga di:

    [Fact]
    public void MultipleAssertTest()
    {
        bool passesValidation = true;

        passesValidation = PassesAssert(true == true);
        passesValidation = PassesAssert(false == true);
        passesValidation = PassesAssert(5 == 1);

        Assert.True(passesValidation);

    }

    private bool PassesAssert(bool expression)
    {
        try
        {
            Assert.True(expression);
            return true;
        }
        catch
        {
            return false;
        }
    }

Questo vi permetterà di eseguire tutti i vostri afferma e fare tutto il test. Tuttavia non è molto utile in quanto non si sa che cosa assert fallisce. Che cosa sarebbe meglio è inferiore in modo da poter effettivamente ottenere risultati fuori del test in modo da sapere quali elementi sicuro.

       private StringBuilder resultMsg;
    [Fact]
    public void MultipleAssertTest()
    {
        bool passesValidation = true;
        resultMsg = new StringBuilder();

        passesValidation = PassesAssert(true == true, "True True test");
        passesValidation = PassesAssert(false == true, "False True test");
        passesValidation = PassesAssert(5 == 1, "5==1 Test");

        Assert.True(passesValidation, resultMsg.ToString());

    }

    private bool PassesAssert(bool expression, string message)
    {
        try
        {
            Assert.True(expression, message);
            return true;
        }
        catch (AssertException ex)
        {
            resultMsg.Append(ex.UserMessage);
            resultMsg.Append(Environment.NewLine);
            return false;
        }
    }

Naturalmente questo richiede un po 'più di lavoro, ma consente di bloccare tutti i vostri asserisce insieme. Si può avvolgere le tue metodi Assert di prova in questo modo. Così si potrebbe dire che si sta estendendo xUnit di avere un processo di asserzione non fallire.

Spero che questo aiuti.

EDIT:. Come per i commenti in ordine per far funzionare tutto questo si avrebbe bisogno di utilizzare l'operatore & le chiamate successive avrebbero sovrascrivere il valore