Afirmar una excepción usando XUnit

Soy un novato en XUnit y Moq. Tengo un método que toma una cadena como argumento. Cómo manejar una excepción usando 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étodo bajo prueba

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;
}

La expresión Assert.Throws detectará la excepción y afirmará el tipo. Sin embargo, está llamando al método bajo prueba fuera de la expresión de aserción y, por lo tanto, falla el caso de prueba.

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

Si está decidido a seguir AAA, puede extraer la acción en su propia 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);
}

Tenga en cuenta que la excepción también se puede utilizar para aserciones detalladas de modo

Si desea ser rígido con respecto a AAA, puede usar Record.Exception de xUnit para capturar la excepción en su etapa Act.

Luego, puede realizar afirmaciones basadas en la excepción capturada en la etapa Assert.

Un ejemplo de esto se puede ver en las pruebas de xUnits .

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

    var ex = Record.Exception(testCode);

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

Depende de usted qué camino desea seguir, y ambos caminos son totalmente compatibles con lo que proporciona xUnit.

Podría considerar algo como esto si desea ceñirse a AAA:

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

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