Pruebas unitarias Fallas WCF

Question

¿Cuál es la mejor manera de probar las fallas esperadas de los servicios de WCF?

Estoy intentando probar la unidad de un servicio WCF que está arrojando (correctamente) FaultExceptions por un cierto error reproducible. Las pruebas unitarias obtienen una instancia del cliente WCF y llaman al método de servicio aplicable, que arroja una FaultException.

Todo eso funciona como era de esperar, pero estoy teniendo dificultades para probarlo, porque la falla hace que el IDE se rompa cuando el error no se detecta en la implementación del servicio. Debido a que estoy usando fallas, y no excepciones, esperaba que el IDE serializara la excepción y la enviara al cliente, donde generaría una excepción.

Veo que hay una opción de configuración para deshabilitar el corte para excepciones específicas no manejadas por el usuario, pero esperaba que alguien pudiera señalar una mejor manera de lograr los mismos resultados, ya que esto no es factible en un equipo ambiente.

He aquí algunos ejemplos de código de lo que la puesta en práctica actualmente parece ...

El proyecto de prueba de unidad tiene una referencia de servicio a mi servicio WCF, y he definido la interfaz como por ejemplo:

[OperationContract(Name = "DoSomething")] 
[FaultContract(typeof(EpicFail))] 
ResponseObject DoSomething(RequestObject requestObject); 

el fallo se define como tal:

[DataContract] 
public class EpicFail 
{ 

    public EpicFail(string action) 
    { 
     this.Reason = "Epic Fail"; 
     this.Action = action; 
    } 

    [DataMember] 
    public string Reason 
    { 
     get; 
     set; 
    } 

    [DataMember] 
    public string Action 
    { 
     get; 
     set; 
    } 

} 

el código que llama al servicio parece vagamente a esto:

[TestMethod()] 
[ExpectedException(typeof(FaultException<EpicFail>))] 
public void FaultTest_Fails_Epicly() 
{ 
    bool testPassed = false; 

    try 
    { 
     ResponseObject resp = GetServiceClient().DoSomething(req); 
    } 
    catch (FaultException<EpicFail>) 
    { 
     testPassed = true; 
    } 

    Assert.IsTrue(testPassed); 
} 

• he editado el código para mostrar que estoy usando el atributo ExpectedException y no parece tener mucho efecto en mantener el IDE/depurador se rompa cuando la excepción se produce en el servicio.

Answer 1

Siempre puede usar ExpectedExceptionAttribute (en NUnit) para asegurarse de que esta sea la excepción lanzada. MSTest tiene un concepto similar también.

[ExpectedException(typeof(MyException))] 
void my_test() 
{ 
    // test 
} 

Si tiene alguna verificación Mock hacer, me gustaría utilizar try/catch y verificar en la captura y luego tirar la excepción.

ACTUALIZACIÓN

Cuando está utilizando ExpectedException atributo, no se supone que detectar la excepción, en cambio es necesario dejar que el NUnit que se ejecuta la prueba de atraparlo.

Si necesita verificar la información especial en la excepción a continuación, se captura la excepción, verificar la información y luego volver a lanzar:

[ExpectedException(typeof(MyException))] 
void my_test() 
{ 
    try 
    { 
     // call the service 
    } 
    catch(MyException ex) 
    { 
      Assert.IsTrue(ex.Message.Contains("error code 200")); 
      throw ex; 
    } 

} 

Answer 2

mattv,

¿Por qué esta prueba tiene que acceder al servicio remotamente? De lo que veo su código:

ResponseObject resp = GetServiceClient().DoSomething(req); 

De alguna manera está recibiendo un cliente de servicio, y no una instancia de servicio en sí.Aconsejo probar la clase concreta de servicio directamente para las pruebas unitarias.

Sin embargo, si necesita este escenario, ¿ha intentado NO CAPTAR la excepción y ejecutar la prueba? ¿Da el mismo resultado?

Y, por cierto, si usted necesita para capturar y volver a lanzar utiliza el siguiente patrón:

try { 
    //Do something 
} 
catch(SomeException e) { 
    //Do something with e 
    throw 
}