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

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.

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

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ê?

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

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.

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.

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.

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:

Espero que isto ajude.

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.

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/

Remova o ProjectTypeGuids do arquivo do projeto.

Agora com fotos:

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

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

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

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

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

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

Espero que isso poupe algum tempo.

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>

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.

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.

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 .

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.

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.

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

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

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.