Devo usar o try catch nos meus métodos de teste?

Estou fazendo testes de unidade.

Estou tentando testar uma função.

Eu chamo isso do meu componente de teste. Mas se a função remota não puder lidar com a exceção, meu componente testador também receberá exceção, eu acho.

Então, devo me preocupar em obter uma exceção no meu componente testador?

Obrigado.

EDITAR:

PS:

Lançar um erro é bom, mas apenas para outras funções, não para usuários finais até que seja a última opção!

OMG eu escrevi uma citação de programação !!

Resposta curta: NÃO.

Não pegue exceções em testes de unidade. Você está testando a unidade para encontrar erros e situações em que as exceções são geradas.

A estrutura de teste de unidade deve lidar com exceções de maneira sã. A maioria das estruturas (se não todas) do xUnit tem uma construção que espera certas exceções que você usa quando deseja induzir uma condição de exceção específica no sistema em teste e passa no teste se a exceção esperada for gerada, mas falhar, caso contrário.

(Em contraste com a resposta de mcottle) Resposta longa: NÃO ... na maioria das vezes

Quando você diz que espera que um teste gere uma exceção específica, você saberá quando QUALQUER linha nesse teste gera essa exceção específica.

Isso não é o mesmo que saber que o método em teste gera a exceção.

Se o seu teste envolver a configuração de um objeto ou contexto (dentro do teste, e não na versão de sua estrutura SetUp), é melhor agrupar a única linha que você realmente deseja testar em uma tentativa / captura, possivelmente com um ajudante.

Por exemplo,

public static class AssertHelper {
    public delegate void Thunk();

    public static void DoesNotThrow<T>(Thunk thunk, string message = "")
        where T: Exception {
        try {
            thunk.Invoke();
        } catch(T) {
            Assert.Fail(message);
        }
    }
}

e depois

[TestMethod]
public void assertHelperInAction() {
    // Random setup stuff here that's too annoying to put in my SetUp
    // method.
    AssertHelper.DoesNotThrow<IllegalArgumentException>(() =>
        {/* My random method under test */})
}

Se esse teste falhar, sei que meu método em teste lançou a exceção, e não algo no material de instalação aleatória.

(Você deve tentar evitar itens de configuração aleatórios. Às vezes, é mais fácil ter algum código de configuração no teste.)

Em geral, você deve deixar escapar a exceção, e a estrutura de teste fornecerá um bom relatório com todas as informações necessárias.

Mas na metodologia TDD, espera-se que você siga os seguintes passos:

1. Escreva um teste
2. Assista a falha e torne o erro compreensível
3. Corrija o código
4. Refatorar o código e o teste

Quando você solta uma exceção, se o erro estiver claro, tudo bem. Mas, às vezes, a exceção é obscura ou até equivocada. Como você pode deixar isso constar no seu código (para você mais tarde, quando tiver esquecido, ou para um membro da equipe que perderá muito tempo tentando descobrir o problema)? Portanto, minha política é: " Se for necessário esclarecer uma falha, você precisará capturar a exceção ".