Affirmer une exception à l'aide de XUnit

Je suis un débutant sur XUnit et Moq. J'ai une méthode qui prend la chaîne comme argument. Comment gérer une exception en utilisant XUnit.

[Fact]
public void ProfileRepository_GetSettingsForUserIDWithInvalidArguments_ThrowsArgumentException() {
    //arrange
    ProfileRepository profiles = new ProfileRepository();
    //act
    var result = profiles.GetSettingsForUserID("");
    //assert
    //The below statement is not working as expected.
    Assert.Throws<ArgumentException>(() => profiles.GetSettingsForUserID(""));
}

Méthode sous test

public IEnumerable<Setting> GetSettingsForUserID(string userid)
{            
    if (string.IsNullOrWhiteSpace(userid)) throw new ArgumentException("User Id Cannot be null");
    var s = profiles.Where(e => e.UserID == userid).SelectMany(e => e.Settings);
    return s;
}

L' expression Assert.Throws interceptera l'exception et affirmera le type. Cependant, vous appelez la méthode testée en dehors de l'expression d'assert et échouez ainsi au scénario de test.

[Fact]
public void ProfileRepository_GetSettingsForUserIDWithInvalidArguments_ThrowsArgumentException()
{
    //arrange
    ProfileRepository profiles = new ProfileRepository();
    // act & assert
    Assert.Throws<ArgumentException>(() => profiles.GetSettingsForUserID(""));
}

Si vous êtes déterminé à suivre AAA, vous pouvez extraire l'action dans sa propre variable.

[Fact]
public void ProfileRepository_GetSettingsForUserIDWithInvalidArguments_ThrowsArgumentException()
{
    //arrange
    ProfileRepository profiles = new ProfileRepository();
    //act
    Action act = () => profiles.GetSettingsForUserID("");
    //assert
    var exception = Assert.Throws<ArgumentException>(act);
    //The thrown exception can be used for even more detailed assertions.
    Assert.Equal("expected error message here", exception.Message);
}

Notez comment l'exception peut également être utilisée pour les assertions détaillées de mode

Si vous voulez être rigide sur AAA, vous pouvez utiliser Record.Exception de xUnit pour capturer l'exception dans votre étape Act.

Vous pouvez ensuite faire des assertions en fonction de l'exception capturée à l'étape Assert.

Un exemple de ceci peut être vu dans les tests xUnits .

[Fact]
public void Exception()
{
    Action testCode = () => { throw new InvalidOperationException(); };

    var ex = Record.Exception(testCode);

    Assert.NotNull(ex);
    Assert.IsType<InvalidOperationException>(ex);
}

C'est à vous de décider du chemin que vous souhaitez suivre, et les deux chemins sont entièrement pris en charge par ce que propose xUnit.

Vous pourriez envisager quelque chose comme ceci si vous voulez vous en tenir à AAA:

// Act 
Task act() => handler.Handle(request);

// Assert
await Assert.ThrowsAsync<MyExpectedException>(act);