Métodos vazios de teste de unidade?

Qual é a melhor maneira de testar a unidade um método que não retorna nada? Especificamente em c #.

O que realmente estou tentando testar é um método que pega um arquivo de log e o analisa para cadeias de caracteres específicas. As seqüências de caracteres são inseridas em um banco de dados. Nada que não tenha sido feito antes, mas sendo MUITO novo no TDD, estou me perguntando se é possível testar isso ou se é algo que realmente não é testado.

Se um método não retornar nada, é um dos seguintes

• imperativo - Você está pedindo ao objeto que faça algo consigo mesmo.
• informativo - basta notificar alguém que algo aconteceu (sem esperar ação ou resposta), respectivamente.

Métodos imperativos - você pode verificar se a tarefa foi realmente executada. Verifique se a mudança de estado realmente ocorreu. por exemplo

void DeductFromBalance( dAmount ) 

pode ser testado verificando se o saldo que lança esta mensagem é realmente menor que o valor inicial por dAmount

Métodos informativos - são raros como um membro da interface pública do objeto ... portanto, normalmente não são testados em unidade. No entanto, se necessário, você pode verificar se o tratamento a ser feito em uma notificação ocorre. por exemplo

void OnAccountDebit( dAmount )  // emails account holder with info

pode ser testado verificando se o email está sendo enviado

Poste mais detalhes sobre seu método real e as pessoas poderão responder melhor.
Atualização : seu método está fazendo duas coisas. Na verdade, eu o dividiria em dois métodos que agora podem ser testados independentemente.

string[] ExamineLogFileForX( string sFileName );
void InsertStringsIntoDatabase( string[] );

A seqüência [] pode ser facilmente verificada, fornecendo ao primeiro método um arquivo fictício e as seqüências esperadas. O segundo é um pouco complicado. Você pode usar um Mock (google ou fluxo de pilha de pesquisa em estruturas de simulação) para imitar o banco de dados ou acessar o banco de dados real e verificar se as cadeias foram inseridas no local correto. Confira esta lista de livros bons ... Eu recomendo o Teste de Unidade Pragmática, se você estiver em crise.
No código, seria usado como

InsertStringsIntoDatabase( ExamineLogFileForX( "c:\OMG.log" ) );

Teste seus efeitos colaterais. Isso inclui:

• Isso gera alguma exceção? (Se for o caso, verifique se sim. Se não, tente alguns casos extremos que talvez não sejam cuidadosos - argumentos nulos são a coisa mais óbvia.)
• Ele joga bem com seus parâmetros? (Se eles são mutáveis, eles os modificam quando não deveriam e vice-versa?)
• Isso tem o efeito correto no estado do objeto / tipo no qual você está chamando?

Claro, há um limite para o quanto você pode testar. Você geralmente não pode testar com todas as entradas possíveis, por exemplo. Teste pragmaticamente - o suficiente para dar a você a confiança de que seu código foi projetado adequadamente e implementado corretamente e o suficiente para atuar como documentação suplementar para o que um chamador pode esperar.

Como sempre: teste o que o método deve fazer!

Deve mudar o estado global (uuh, cheiro de código!) Em algum lugar?

Deve chamar em uma interface?

Deveria lançar uma exceção quando chamado com os parâmetros errados?

Não deveria lançar exceção quando chamado com os parâmetros corretos?

Deveria ...?

Tipos de retorno nulo / sub-rotinas são notícias antigas. Não faço um tipo de retorno nulo (a menos que eu esteja sendo extremamente preguiçoso) há 8 anos (desde o momento desta resposta, um pouco antes da pergunta).

Em vez de um método como:

public void SendEmailToCustomer()

Crie um método que siga o paradigma int.TryParse () da Microsoft:

public bool TrySendEmailToCustomer()

Talvez não exista nenhuma informação que seu método precise retornar para uso a longo prazo, mas retornar o estado do método depois que ele executa seu trabalho é uma grande utilidade para o chamador.

Além disso, bool não é o único tipo de estado. Há várias vezes em que uma sub-rotina feita anteriormente pode realmente retornar três ou mais estados diferentes (bom, normal, ruim etc.). Nesses casos, você usaria apenas

public StateEnum TrySendEmailToCustomer()

No entanto, embora o Try-Paradigm responda de alguma forma a essa pergunta sobre como testar um retorno nulo, há outras considerações também. Por exemplo, durante / após um ciclo "TDD", você estaria "Refatorando" e notaria que está fazendo duas coisas com seu método ... quebrando, assim, o "Princípio de responsabilidade única". Portanto, isso deve ser tratado primeiro. Segundo, você pode ter identificado uma dependência ... está tocando em Dados "persistentes".

Se você estiver executando o material de acesso a dados no método em questão, precisará refatorar para uma arquitetura de camada n ou camada. Mas podemos assumir que quando você diz "As cadeias são inseridas em um banco de dados", na verdade quer dizer que está chamando uma camada de lógica de negócios ou algo assim. Sim, vamos assumir isso.

Quando seu objeto é instanciado, agora você entende que ele possui dependências. É quando você precisa decidir se fará Injeção de Dependência no Objeto ou no Método. Isso significa que seu construtor ou o método em questão precisa de um novo parâmetro:

public <Constructor/MethodName> (IBusinessDataEtc otherLayerOrTierObject, string[] stuffToInsert)

Agora que você pode aceitar uma interface do seu objeto de camada de negócios / dados, pode simulá-la durante testes de unidade e não tem dependências ou medo de testes de integração "acidentais".

Então, no seu código ativo, você passa um IBusinessDataEtcobjeto REAL . Mas em seu teste de unidade, você passa um IBusinessDataEtcobjeto MOCK . Nesse Mock, você pode incluir as propriedades que não são da interface, int XMethodWasCalledCountou algo cujos estados são atualizados quando os métodos da interface são chamados.

Portanto, seu teste de unidade passará por seu (s) método (s) em questão, execute qualquer lógica que ele tenha e chame um ou dois ou um conjunto selecionado de métodos em seu IBusinessDataEtcobjeto. Quando você faz suas afirmações no final do seu teste de unidade, você tem algumas coisas para testar agora.

1. O estado da "sub-rotina", que agora é um método Try-Paradigm.
2. O estado do seu IBusinessDataEtcobjeto simulado .

Para obter mais informações sobre as idéias de injeção de dependência no nível da construção ... no que se refere ao teste de unidade ... consulte os padrões de design do Builder. Ele adiciona mais uma interface e classe para cada interface / classe atual que você possui, mas elas são muito pequenas e fornecem enormes aumentos de funcionalidade para um melhor teste de unidade.

Tente o seguinte:

[TestMethod]
public void TestSomething()
{
    try
    {
        YourMethodCall();
        Assert.IsTrue(true);
    }
    catch {
        Assert.IsTrue(false);
    }
}

Você pode até tentar desta maneira:

[TestMethod]
public void ReadFiles()
{
    try
    {
        Read();
        return; // indicates success
    }
    catch (Exception ex)
    {
        Assert.Fail(ex.Message);
    }
}

isso terá algum efeito em um objeto ... consulta o resultado do efeito. Se não tem efeito visível, não vale a pena testar a unidade!

Presumivelmente, o método faz alguma coisa e não volta simplesmente?

Supondo que este seja o caso, então:

1. Se ele modificar o estado de seu objeto proprietário, você deverá testar se o estado foi alterado corretamente.
2. Se ele receber algum objeto como parâmetro e modificá-lo, você deverá testar se o objeto foi modificado corretamente.
3. Se lançar exceções em certos casos, teste se essas exceções foram lançadas corretamente.
4. Se o seu comportamento variar com base no estado de seu próprio objeto, ou em algum outro objeto, pré-ajuste o estado e teste o método possui a forma correta através de um dos três métodos de teste acima).

Se você nos informar o que o método faz, eu poderia ser mais específico.

Use o Rhino Mocks para definir quais chamadas, ações e exceções podem ser esperadas. Supondo que você possa zombar ou remover partes do seu método. Difícil de saber sem conhecer algumas especificidades aqui sobre o método, ou mesmo contexto.

Depende do que está fazendo. Se houver parâmetros, passe as simulações que você poderá perguntar posteriormente se elas foram chamadas com o conjunto correto de parâmetros.

Qualquer que seja a instância que você esteja usando para chamar o método void, você pode simplesmente usar,Verfiy

Por exemplo:

No meu caso, _Logé a instância e LogMessageé o método a ser testado:

try
{
    this._log.Verify(x => x.LogMessage(Logger.WillisLogLevel.Info, Logger.WillisLogger.Usage, "Created the Student with name as"), "Failure");
}
Catch 
{
    Assert.IsFalse(ex is Moq.MockException);
}

Os Verifylançamentos são uma exceção devido à falha do método que o teste falharia?