A verificação aceita apenas métodos de 0 parâmetros; Como faço para testar que outros métodos lançam exceções?

Question

Estou me perguntando qual é a melhor prática para testar exceções no Dunit. Não estou muito familiarizado com os indicadores de método em Delphi. Existe alguma possibilidade de vincular argumentos a um ponteiro de método para que ele possa ser invocado sem argumentos. No momento, eu sempre escrevo um método adicional que faz isso 'ligação' manualmente. Isso será irritante se o SUT tiver muitos métodos de arremesso.

// What i did before i knew abput CheckExcepion
procedure MyTest.MyMethod_BadInput_Throws;
var
    res: Boolean;
begin
    res := false;
    try
        sut.MyMethod('this is bad');
    except
        on e : MyExpectedException do:
            res := true;
    end;
    CheckTrue(res);
end;

// What i do now
procedure MyTest.MyMethodWithBadInput;
begin
    sut.MyMethod('this is bad');
end;

procedure MyTest.MyMethod_BadInput_Throws;
begin
    CheckException(MyMethodWithBadInput, MyExpectedException);
end;

// this would be nice
procedure MyTest.MyMethod_BadInput_Throws;
begin
    CheckException(
        BindArguments(sut.MyMethod, 'this is bad'),  // <-- how to do this
        MyExpectedException);
end;

Answer 1

Você pode usar StartExpectingException para cercar sua chamada de método).

StartExpectingException(MyException);
MyMethod(MyParam);
StopExpectingException();

Answer 2

Ainda não sei se a Dunit suporta, mas este é um caso de uso perfeito para métodos anônimos introduzidos em Delphi 2010. Se a Dunit não o suportar, você poderá facilmente modificar a fonte.

Answer 3

Como observado, este é um ótimo lugar para métodos anônimos.

Eis como eu faço isso. Eu "peguei emprestado" isso de Alex Ciobanu:

procedure TestTMyClass.CheckException(aExceptionType: TClassOfException; aCode: TTestCode; const aMessage: String);
var
  WasException: Boolean;
begin
  WasException := False;
  try
    aCode;
  except
    on E: Exception do
    begin
      if E is aExceptionType then
      begin
        WasException := True;
      end;
    end;
  end;
  Check(WasException, aMessage);
end;

Então chame com algo como:

CheckException(ETestingException, 
             procedure begin FMyClass.RaiseTestingException end,      
             'The ETestingException exception didn''t get raised.  That is impossible!');

Answer 4

Usar StartExpectingException() Não é a melhor maneira, caso você queira testar mais do que um caso de exceção. Para testar todos os casos possíveis no meu procedimento de teste, juntamente com exceções, uso este algoritmo:

uses
  Dialogs;
procedure MyTest.MyMethod_Test;
begin
  // Test for Exceptions
  try
    MyMethod(MyParam1CreatingException1);
    ShowMessage('Error! There should have been exception: Exxx here!');
    Check(false);
  except on E: Exception do Check(E is  ExceptionType1); end; // This exception is OK
  try
    MyMethod(MyParam2CreatingException2);
    ShowMessage('Error! There should have been exception: Exxx here!');
    Check(false);
  except on E: Exception do Check(E is  ExceptionType2); end; // This exception is OK
  // ... test other exceptions ...

  // Test other parameters
  CheckEquals('result1', MyMethod(MyParam1));
  CheckEquals('result2', MyMethod(MyParam2));
  // ... other tests ...
end;

A razão pela qual eu uso ShowMessage('Error! There should be exception: Exxx here!'); em vez do fornecido Check(false, 'There should have been an EListError.'); método é que, no meu caso (Delphi6), o Check(boolean, 'Message') não funciona - ele não mostra a mensagem para o caso de a verificação estar dentro try...except Bloco (não sei por quê).

Answer 5

Esta é a versão funcional e aprimorada da resposta de Nick Hodges, que subclass TestFramework.TTestCase:

uses
  TestFramework, System.SysUtils;
type
  TTestCode = reference to procedure;

  TTestCasePlus = class(TestFramework.TTestCase)
    procedure CheckException(
      ExceptionType: TClass; Code: TTestCode; const Message: String = '');
  end;

implementation

procedure TTestCasePlus.CheckException(
  ExceptionType: TClass; Code: TTestCode; const Message: String = '');
{ Check whether some code raises a specific exception type.

Adapted from http://stackoverflow.com/a/5615560/797744

Example:

  Self.CheckException(EConvertError,
                      procedure begin UnformatTimestamp('invalidstr') end);

@param ExceptionType: The exception class which we check if it was raised.
@param Code: Code in the form of an anonymous method that should raise the
  exception.
@param Message: Output message on check failure. }
var
  WasRaised: Boolean;
begin
  WasRaised := False;
  try
    Code;
  except
    on E: Exception do
      if E is ExceptionType then
        WasRaised := True;
  end;
  Check(WasRaised, Message);
end;

Um bom bônus a esse método de verificar se uma exceção foi levantada Start/StopExpectingException() É isso que você pode executar o testrunner na construção de depuração e isso não vai incomodá -lo com "Exceção foi levantada. Break? Continue?" Toda vez que uma exceção é levantada-mesmo que tenha sido tratada.