Como executo o NUnit no modo de depuração do Visual Studio?

120

Recentemente, eu estou criando uma estrutura de teste para um pouco de C # em que estou trabalhando. Eu tenho o NUnit configurado e um novo projeto no meu espaço de trabalho para testar o componente. Tudo funciona bem se eu carregar meus testes de unidade da Nunit (v2.4), mas cheguei ao ponto em que seria realmente útil executar no modo de depuração e definir alguns pontos de interrupção.

Eu tentei as sugestões de vários guias que sugerem alterar as propriedades 'Debug' do projeto de teste:

Start external program: C:\Program Files\NUnit 2.4.8\bin\nunit-console.exe
Command line arguments: /assembly: <full-path-to-solution>\TestDSP\bin\Debug\TestDSP.dll

Estou usando a versão do console lá, mas tentei chamar a GUI também. Ambos me dão o mesmo erro quando tento iniciar a depuração:

Cannot start test project 'TestDSP' because the project does not contain any tests.

Isso ocorre porque eu normalmente carrego \ DSP.nunit na GUI do Nunit e é aí que os testes são realizados?

Estou começando a pensar que o problema pode ser que o VS deseja executar sua própria estrutura de teste e é por isso que está falhando em encontrar os testes da NUnit?

Edit : Para aqueles que perguntam sobre equipamentos de teste, um dos meus arquivos .cs no projeto TestDSP é mais ou menos assim:

namespace Some.TestNamespace
{
    // Testing framework includes
    using NUnit.Framework;

    [TestFixture]
    public class FirFilterTest
    {
        [Test]
        public void Test01_ConstructorTest()
        {
            ...some tests...
        }
    }
}

... Eu sou muito novo em C # e na estrutura de teste do NUnit, então é perfeitamente possível que eu tenha perdido algumas informações cruciais ;-)

Solução final : O grande problema foi o projeto que eu usei. Se você escolher Other Languages -> Visual C# -> Test -> Test Project... ao escolher o tipo de projeto, o Visual Studio tentará usar sua própria estrutura de teste, até onde eu sei. Você deve escolher um projeto normal da biblioteca de classes C # e, em seguida, as instruções na minha resposta selecionada funcionarão.

Jon Cage
fonte
Sua classe de acessórios de teste me parece bem, portanto deve ser algo no projeto, como você sugeriu.
22139 Patrick McDonald
2
Parecido com esta pergunta: stackoverflow.com/questions/247900/... A resposta é a mesma ...
Patrick Desjardins

Respostas:

46

Eu uso a mesma técnica que você está tentando Jon, sem o sinalizador / assembly, ou seja,

Start External Program: C:\Program Files\NUnit 2.4.8\bin\nunit.exe

Command line arguments: "<path>\bin\Debug\Quotes.Domain.Tests.dll"

O TestDSP.dll contém todas as suas TestFixtures?

Como meu projeto de teste não é o projeto de inicialização da solução, eu executo meus testes clicando com o botão direito do mouse no projeto de teste e escolhendo Depurar -> Iniciar Nova Instância

Patrick McDonald
fonte
1
Eu tentei o que você sugeriu (remover o / assembly), mas isso não faz diferença. Quando inicio uma nova instância, produz o erro. Eu estou pensando que tem a ver principalmente com o fato de que, quando criei o projeto TestDSP, criei-o a partir do modelo de projeto de teste VisualStudio integrado, para que ele esteja procurando a estrutura de teste errada.
21710 Jon Cage
3
Finalmente consegui funcionar. Eu estava certo quanto às opções do projeto que o pararam - recriar o projeto de teste usando o modelo de classe padrão corrigiu o problema.
21810 Jon Cage
1
Ajuda se você também adicionar /runaos seus argumentos de linha de comando * que iniciarão automaticamente a execução de testes ... Eu também resumi tudo (usando imagens) no meu blog .
Robert Koritnik
6
Caso as pessoas não consultem a publicação do blog de Robert (muito útil) ( erraticdev.blogspot.com/2012/01/… ): para o .NET 4.0 e versões posteriores, acredito que você também precise adicionar isso ao nunit.exe.config : <startup> <supportedRuntime version = "4.0" /> </startup>.
Devuxer
3
Acompanhamento: Nas versões posteriores do NUnit (a versão mais recente até hoje é a v2.6.1), é necessário comentar <supportedRuntime version="v2.0.50727" />em nunit.exe.config.
Devuxer 16/08/12
102

Quando preciso depurar meus testes NUnit, simplesmente conecto ao aplicativo NUnit GUI nunit-agent.exeusando "Debug | Attach to Process" e executo os testes a partir da GUI. Quaisquer pontos de interrupção nos meus testes (ou o código que eles estão testando) são atingidos. Estou entendendo mal sua pergunta ou isso funcionará para você?

Matt Hamilton
fonte
7
Para sua informação (e de outras pessoas): o Debug | Attach não está disponível nas edições Express do VS.
Richard
15
Esteja ciente de que você tem que selecionar "Ativar Suporte Visual Studio" na caixa de diálogo Configurações de NUnit -> Suporte IDE
Julio Garcia
8
Para .NET 4.0 e posterior, eu acredito que você também tem que adicionar este a nunit.exe.config: <startup> <supportedRuntime version="4.0" /> </startup>.
Devuxer
1
Este é um atalho rápido para anexar ao processo correto (executado no Package Manager Console): ($ dte.Debugger.LocalProcesses |? {$ _. Name.EndsWith ("nunit-agent.exe")}). Attach ()
Bart
7
FYI: você precisa anexar a depuração ao processo chamado "nunit-agent.exe" e NÃO "nunit.exe". Caso contrário, os pontos de interrupção são ignorados e você quer saber porque ...
Jenny O'Reilly
21

Basta remover a linha que parece

<ProjectTypeGuids>
    {3AC096D0-A1C2-E12C-1390-A8335801FDAB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}
</ProjectTypeGuids>

do seu arquivo de projeto. Essa linha basicamente diz ao VS.Net que é um projeto de Teste, portanto, o "Não é possível iniciar o projeto de teste". Para sua informação, aqui o 1º Guid diz "é um teste", o segundo diz "é C #". Para obter informações sobre esses Guids: http://www.mztools.com/Articles/2008/MZ2008017.aspx

user276648
fonte
18

Além da resposta fornecida por @Justin, aqui estão mais alguns detalhes do NUnit 2.6.

O uso do NUnit 2.6 é anexado ao nunit.exe ou nunit-console.exe e NÃO ao agente. A configuração observada por @Justin é um pouco diferente. Abaixo está um exemplo de nunit.exe.config (o mesmo para nunit-console.exe.config).

<startup useLegacyV2RuntimeActivationPolicy="true">
  <!-- Comment out the next line to force use of .NET 4.0 -->
  <supportedRuntime version="v2.0.50727" />  
  <supportedRuntime version="v4.0.30319" />
</startup>

Para o projeto de teste do .NET 4, para obter pontos de interrupção, é necessário comentar ou remover a linha v2.0, conforme o comentário sugere. Depois disso, consegui depurar o projeto de teste do .NET 4.0.

dblood
fonte
Eu tive sucesso apenas com a v2.0.50727linha ao depurar assemblies .NET 2 do VS2005 com nunit. (A v4linha impedido o depurador de VS 2005 de fixação.)
Martin Ba
17

Se você estiver usando o NUnit 2.4 ou mais recente, poderá colocar o seguinte código em sua SetUpFixtureclasse. (Você pode fazer isso com versões mais antigas, mas precisará fazer o equivalente que tiver ao SetUpFixture, ou copiá-lo para o próprio teste.)

[SetUpFixture]
public class SetupFixtureClass
{
    [SetUp]
    public void StartTesting()
    {
        System.Diagnostics.Debugger.Launch();
    }
}

O que Debugger.Launch()faz é fazer com que a seguinte caixa de diálogo seja exibida quando você clica em Executar dentro do NUnit.

Diálogo JIT Debugger

Em seguida, você escolhe sua instância em execução do visual studio com seu projeto aberto (o 2º na minha captura de tela), o depurador será anexado e quaisquer pontos de interrupção ou exceção serão exibidos no Visual Studio.

Scott Chamberlain
fonte
12

No Nunit 3.0.1 (estou usando o VS2013), abra no menu principal> Teste> Windows> Explorador de Testes. Em "Test Explorer", clique com o botão direito do mouse no caso de teste e você poderá ver: insira a descrição da imagem aqui

Espero que isto ajude.

Quinn
fonte
2
Obrigado por esta resposta. Muito mais simples que todos os outros.
dano 13/10
Estou usando o NUnit 2.5.9 no VS 2015 e funcionou com uma extensão do VS denominada 'NUnit 2 Test Adapter'. Você pode executar o teste na janela Test Explorer.
mggSoft
6

Instale o TestDriven.NET , um plug-in para o Visual Studio

A partir daí, você pode clicar com o botão direito do mouse no seu conjunto de testes de unidade e clicar em Executar Testes para executar todo o conjunto, clicar com o botão direito do mouse em uma classe TestFixture para executar apenas os testes nessa classe ou clicar com o botão direito do mouse em um método de Teste para executar exatamente esse método.

Você também tem a opção de Testar com depurador, se precisar interromper seus testes no modo de depuração.

Jon Limjap
fonte
2
US $ 170 são ridiculamente altos para essa ferramenta. Apreensão de preços, alguém?
Ben Hardy
Sim. Por esse tipo de dinheiro, prefiro investir no JetBrains Resharper, que oferece gratuitamente o Test Runner com integração de depuração e vários outros recursos de produtividade.
Roman
Com o Visual Studio 2012, você pode obter o NUnit Test Runner com Nuget gratuitamente.
9119 Jon Limjap
6

Experimente o NUnitit - um suplemento do Visual Studio de código aberto para depurar casos de teste do NUnit

Página inicial - http://nunitit.codeplex.com/

abhilash
fonte
Isso é muito bom, embora eu não consigo encontrar uma maneira de dizer que ele apenas executa um único teste (?)
Jon gaiola
3

Agora com fotos:

  1. Execute o NUnit gui (faça o download do 2.6.2 aqui ) e vá paraFile -> Open Project

insira a descrição da imagem aqui

  1. Selecione seu teste .dllna pasta bin (C:\......\[SolutionFolder][ProjectFolder]\bin\Debug\xxxxTests.dll )

  2. Vá para o Visual Studio Debug -> Attach to process (a janela Anexar ao processo será aberta)

  3. Na lista, role para baixo e selecione nunit-agent.exee clique emAttach

insira a descrição da imagem aqui

  1. Nesse ponto, os pontos de interrupção em seus testes devem ficar vermelhos maduros (do oco).

  2. Clique Runem Nunit Guie você deve obter o seu ponto de interrupção atingido ...

Espero que isso poupe algum tempo.

Matas Vaitkevicius
fonte
2

Se você conseguir fazer o console / ou a GUI funcionar, mas seus pontos de interrupção não estiverem sendo atingidos, pode ser que o aplicativo esteja executando um tempo de execução .NET diferente do NUnit. Verifique se o seu nunit-console.exe.config / nunit.exe.config possui o tempo de execução especificado (as configurações estão no mesmo diretório que o ex da unidade). Especifique o tempo de execução usando o nó de inicialização:

<configuration>
    <startup>
       <supportedRuntime version="4.0" />
    </startup>
Justin Turner
fonte
2

Se o caminho do projeto contiver espaços, por exemplo, "Novo Projeto" no caminho <path>\bin\Debug\New Project\Quotes.Domain.Tests.dll , coloque o caminho do projeto Opção Iniciar -> Argumentos da Linha de Comando entre aspas duplas.

Passei muito tempo para descobrir isso.

Gyan Sada
fonte
1

Sobre o que o Sr. Patrick McDonald disse

Como meu projeto de teste não é o projeto de inicialização da solução, eu executo meus testes clicando com o botão direito do mouse no projeto de teste e escolhendo Depurar -> Iniciar Nova Instância

Tentei me inscrever na minha biblioteca de classes de teste, mas obtive algum erro em relação ao caminho. Por isso, tentei remover os 'Argumentos da linha de comando' e, felizmente, funcionou bem e conforme o esperado.

Abdul Rahman Kayali
fonte
0

Parece que você está tentando usar a biblioteca errada. O NUnit pode iniciar apenas se a dll que você estiver usando contiver TestFixtures.

+1 em TestDriven.Net. Eu tive a chance de usá-lo várias vezes. Você pode fazer o download da versão pessoal para fins de avaliação, de acordo com a licença em http://testdriven.net/purchase_licenses.aspx .

Mike737
fonte
Veja a edição recente - Eu tenho um acessório de teste, embora seja inteiramente possível que eu não o configurei corretamente.
Jon gaiola
0

Eu recebi o mesmo erro com o MSTest. Descobri que na janela Saída de teste , alguns dos testes tinham IDs duplicados e não podiam ser carregados. Eu removi todos os testes duplicados e agora consegui executá-los quando inicio o projeto.

Vijay
fonte
0

Agora também há uma extensão "Visual NUnit" que permitirá executar os testes no Visual studio, da mesma forma que a compilação nas alças da estrutura de teste. Confira no gerenciador de extensões.

iamkrillin
fonte
0

Abra o Visual Studio ---> seu projeto ---> selecione 'Propriedades' ---> selecione 'Depurar' -> selecione 'Iniciar programa externo' e defina o caminho do seu NUnit (por exemplo: Iniciar programa externo = C : \ Arquivos de Programas \ NUnit 2.6.2 \ bin \ nunit.exe) ----> Salvar

Depois de definir isso, clique em Debug

Farija Khan
fonte
0

Para mim, a solução foi adaptar o arquivo de configuração da unidade. Para usar a unidade com a estrutura 4.5-.Net e a opção de compilação x64, tive que adicionar uma linha à tag de inicialização (versão de tempo de execução suportada).

<startup useLegacyV2RuntimeActivationPolicy="true">
        <!-- Comment out the next line to force use of .NET 4.0 -->
        <supportedRuntime version="v4.0.30319" />
</startup>

Posteriormente, eu poderia começar clicando com o botão direito do mouse em Debug do projeto de teste -> Iniciar nova instância. Antes, eu precisava novamente anexar manualmente o projeto ao processo.

Minhas propriedades de depuração foram: C: \ Arquivos de programas (x86) \ NUnit 2.6.4 \ bin \ nunit.exe com o argumento do local da DLL a ser testada.

Mais informações: nunit for testing with .NET 4.0

HauiB
fonte
-1

Veja se isso ajuda .. Como adicionar o NUnit no Visual Studio

(RighteousRant) Embora pessoalmente eu não goste dessa abordagem. Se você precisar de um depurador enquanto estiver testando seu código, é um "cheiro" porque você não tem confiança suficiente / sabe como seu código funciona e precisa do depurador para lhe dizer isso. O TDD deve liberá-lo da necessidade de um depurador, se bem feito. Use 'Attach debugger to NUNit' apenas em casos raros ou quando você estiver pesquisando no código de outra pessoa.

Gishu
fonte
Eu tentei as sugestões lá sem sucesso. Você claramente tem um bom nariz. Eu sei que meu código não funciona, pois a saída que estou obtendo para o primeiro bloco de implementação está recebendo respostas muito diferentes para a minha referência de teste. Então agora estou tentando me aprofundar para encontrar a causa do problema. Prefiro fazer isso isoladamente com o restante do programa (daí a necessidade de executar testes de unidade no modo de depuração). Para o registro, este é o código que outra pessoa escreveu que foi convertido a partir de um outro algoritmo pessoas: - /
Jon gaiola
Então isso se enquadra na última cláusula da minha última linha :) Estranho que você não consiga fazê-lo funcionar .. muito ruim. Eu diria que basta anexar ao processo (Alt + D + P) sem insistir nele .. #
317
Não há cheiro aqui - eu tenho um caso de teste que falha em determinados ambientes (um resultado muito errado é retornado) e preciso descobrir o motivo. Para fazer isso, quero depurá-lo e descobrir onde está falhando nesse ambiente, para que eu possa corrigir o código e fazer o teste passar em todos os lugares. Esta parece ser padrão vermelho / Tipo de material verde ...
BrainSlugs83
@ BrainSlugs83 - muito tempo desde que escrevi isso. Sou (ainda) contra a depuração de seus testes como uma prática principal de trabalho. Casos extremos - estou bem em cair para o depurador. Mesmo assim, eu provavelmente insira stmts de log primeiro. Acho que decorre do fato de ter observado muitas pessoas usando um ciclo Code-Crash-Debug-Adjust que é otimizado para o ciclo Code-Crash-Adjust com o depurador continuamente ligado.
Gishu