Teste de unidade, NUnit ou Visual studio?

Estou usando o Visual Studio (às vezes resharper) para executar meu teste de unidade.

Já ouvi falar do NUnit, mas não sei muito sobre ele ...

Devo me preocupar com isso? Ele pode oferecer algo melhor do que um estúdio visual?

Devo usar o NUnit e por quê?

NUnit tem poucas vantagens sobre MS-Test

1. Atributo Suite - pode agregar testes e executá-los separadamente (útil para grandes projetos com testes rápidos e lentos, por exemplo)
2. Método de declaração legível, por exemplo, Assert.AreEqual(expected, actual)vsAssert.That(actual, Is.EqualTo(expected))
3. NUnit tem atualizações de versão frequentes - MS-Test tem apenas uma por versão do VS.
4. Muitos corredores integrados, incluindo Resharper e TestDriven.NET
5. Asserção de mensagem de exceção esperada - pode ser feita usando o atributo em NUnit, mas deve ser feita usando Try-Catch em MS-Test
6. [TestCase]! NUnit permite testes parametrizados.

Da minha perspectiva atual (após 8 meses de desenvolvimento, com cerca de 10 desenvolvedores em média) gostaria de aconselhar contra usando MSTest pelas seguintes razões

• A estrutura em si é bastante lenta. Não me refiro ao código de teste que você escreve - está sob seu controle. Quero dizer, a estrutura que executa esses testes é lenta, seja executando um conjunto de testes, testes individuais etc.
• A necessidade de manter um arquivo de metadados de teste que sempre leva a complicações quando vários desenvolvedores estão trabalhando nele (recriando, por exemplo, os metadados, etc.). Todos os outros conjuntos de testes não precisam de um arquivo de metadados. É bom organizar seus testes, mas você pode conseguir o mesmo por meio de namespaces, classes e nomes de métodos.
• Fazendo integração contínua, se você deseja executar testes de unidade em sua máquina de construção, você precisará instalar o Visual Studio nessa máquina.

Em outras palavras, se eu tivesse que decidir novamente 8 meses atrás, provavelmente tomaria o NUnit. Posso não ter o relatório de resultados de teste integrado, mas os desenvolvedores teriam uma experiência de teste mais perfeita.

Aqui está minha experiência com o MS Test

• Estamos executando o MS Test com cerca de 3800 Test.
• A execução dos testes demora muito, o que é doloroso quando se executam testes únicos.
• Demora cerca de 1 GB de memória para executar os testes. Não, não é devido a vazamentos de memória em nossos testes. Freqüentemente, encontramos OutOfMemoryExceptions.
• Como ele usa tantos recursos, estamos começando a executar os testes a partir de arquivos em lote. Então, para que serve toda a integração?
• É cheio de erros e instável:
  • Por exemplo, se você remover o Atributo [Ignorar] de um teste, ele não o reconhecerá, porque armazenará informações sobre os testes em algum lugar. Você precisa atualizar a lista de testes, o que às vezes resolve o problema, ou reiniciar o VS.
  • Ele não copia os assemblies de referência aleatoriamente para o diretório out.
  • Itens de implantação (arquivos adicionais a serem usados) simplesmente não funcionam corretamente. Eles são ignorados aleatoriamente.
• Há informações ocultas (não visíveis no código de teste) nos arquivos vsmdi e testrunconfig. Se você não se importar com isso, pode não funcionar.
• Funcionalmente, pode ser comparável ao NUnit, mas é muito caro se você considerar o uso da edição VS tester.

Adição: temos mais alguns testes agora, nem posso dizer quantos. É impossível executá-los mais a partir do Visual Studio, devido a OutOfMemoryExceptions e outros problemas de instabilidade. Executamos os testes a partir de scripts. Seria fácil visualizar os resultados do teste no Visual Studio, mas quando a solução é aberta, o VS trava (todas as vezes). Portanto, precisamos pesquisar os testes com falha usando a pesquisa de texto. Não há mais vantagem de uma ferramenta integrada.

Outra atualização : estamos usando o VS 2013 agora. Muitas coisas mudaram. Eles reescreveram o executor de teste MS Test pela terceira vez desde que começamos. Isso causou muitas mudanças significativas, mas nenhuma das novas versões estava fazendo nada melhor. Estamos felizes por não termos usado os recursos sofisticados do MS Test, porque todos eles não são mais suportados. É realmente uma pena. Ainda estamos usando scripts para construir e executar todos os testes de unidade, porque é mais prático. O Visual Studio levou alguns minutos para iniciar a execução dos testes (o tempo mede após a compilação até o início do primeiro teste). Eles provavelmente consertam com uma atualização e isso pode ser um problema específico do nosso projeto. No entanto, o Resharper é muito mais rápido ao executar os mesmos testes.

Conclusão : pelo menos em combinação com o Resharper, o MS Test é útil. E espero que eles finalmente descubram como o executor de teste deve ser escrito e não façam esse tipo de alteração repentina quando atualizarmos o Visual Studio na próxima vez.

O NUnit pode ser usado em combinação com o estúdio visual. É uma estrutura, não um programa separado. Então você pode se importar e ver se combina com você :).

alt text http://i3.codeplex.com/Project/Download/FileDownload.aspx?ProjectName=nunitit&DownloadId=61802

"Depois de instalar o plugin, você encontrará um novo submenu no menu de ferramentas."

Consulte http://nunitit.codeplex.com/ para obter mais informações sobre como importá-lo.

Além disso, muito pode ser encontrado usando a pesquisa do SO. Este tópico lista as vantagens do NUnit sobre o teste padrão MS, por exemplo.

A maior vantagem do MS-Test sobre o NUnit é que o MS-Test pode gerar objetos simulados usando o Reflection. Achei muito útil

NUnit funciona com a edição padrão do VS.

Não tenho certeza sobre os outros, mas o NUnit fornece uma boa interface gráfica e um console para executar seus testes de unidade e também você pode gerar um relatório do resultado da execução do teste NUnit que forneceria os detalhes de onde o teste falhou ou passou e também em que horas faça para o seu teste de unidade

NUnit é uma estrutura de teste de unidade, que também é compatível com resharper. Acho que você está usando a estrutura de teste de unidade da Microsoft, então o NUnit é apenas uma alternativa ao produto da Microsoft;)

Aqui está o link para a página inicial da NUnit: http://nunit.org

No NUnit , os testes não são executados em paralelo. Em vez disso, parece que todos os testes são executados em um único thread. No MSTest, cada teste é instanciado em um thread separado, o que resulta nas execuções intercaladas. Portanto, se o teste A depender do teste B para seu sucesso, provavelmente falhará, pois o teste B provavelmente começará a ser executado conforme o teste A está em execução.

Se você estiver usando o Visual Studio, você deve usar o NUnit para fazer o teste de unidade e se estiver executando o java (Netbeans), você deve usar o JUnit para o teste de unidade.

Aqui está um exemplo de um teste simples de unidade de calculadora

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using SimpleCalculator;
using NUnit.Framework;

namespace CalculatorTest
{
    [TestFixture]
    public class Class1
    {
        public Calculator _calculator;
        [TestFixtureSetUp]
        public void Initialize()
        {
            _calculator = new Calculator();
        }
        [Test]
        public void DivideTest()
        {
            int a = 10;
            int b = 2;
            int expectedValue = a / b;
            int actualvalue = _calculator.Divide(a, b);
            Assert.AreEqual(expectedValue, actualvalue,"Failure");

        }
    }
}