Como me concentro em uma especificação no jasmine.js?

154

Eu tenho um monte de especificações com falha de uma mudança arquitetônica bastante grande. Eu gostaria de trabalhar para corrigi-los um por um, marcando cada um com 'foco'.

O jasmine.js possui um recurso como este? Jurei que li em um ponto que sim, mas não o vejo nos documentos.

Dane O'Connor
fonte
1
@ pontos resposta recentes de phil-Pirozhkov que este foi introduzido para Jaswine em v2.1
alxndr

Respostas:

56

Você pode executar uma única especificação usando o URL da especificação

describe("MySpec", function() { 
  it('function 1', function() { 
    //... 
  }) 

  it('function 2', function() { 
    //... 
  } 

}) 

Agora você pode executar apenas toda a especificação por este URL http://localhost:8888?spec=MySpece fazer o primeiro teste comhttp://localhost:8888?spec=MySpec+function+1

Andreas Köberle
fonte
10
Ou basta clicar sobre especificações ou testes individuais na página de resultados
jackocnr
Impressionante. Agora, como faço para executar este: describe("MySpec", ...)e não este describe("MySpec blah blah", ...):? Parece estar fazendo uma correspondência de substring.
Ian Phillips
descrevem.only é a resposta correta se estiver usando o jasmim 2.0, não tenho certeza sobre outras versões.
Davidjnelson
http://localhost:8888?spec=function+1deve funcionar também (muitas vezes não é necessário especificar MySpec)
penkman lee
123
fdescribe,fit
basarat 19/03/2015
269

Ao usar o Karma, você pode ativar apenas um teste com fitou fdescribe( iite ddescribeno Jasmine antes da 2.1).


Isso é executado apenas Spec1:

// or "ddescribe" in Jasmine prior 2.1
fdescribe('Spec1', function () {
    it('should do something', function () {
        // ...
    });
});

describe('Spec2', function () {
    it('should do something', function () {
        // ...
    });
});

Isso é executado apenas testA:

describe('Spec1', function () {

    // or "iit" in Jasmine prior 2.1
    fit('testA', function () {
        // ...
    });

    it('testB', function () {
        // ...
    });

});
Hudvoy
fonte
7
é uma boa dica, mas atualmente não está em jasmim. isso é permitido por corredores de testes como o karma. para obter mais informações, leia: github.com/pivotal/jasmine/pull/309
p1100i
77
O Jasmine 2.1 apresenta isso como fdescribee fit: github.com/jasmine/jasmine/commit/…
alxndr
10
Você teria que ter cuidado para não confirmar especificações ii ou dd. É fácil perder algo assim.
Rimian
@jameshfisher, a pergunta foi feita em 2011. Além disso, iite ddescribesão adições ao Karma, não ao Jasmine.
Justus Romijn 25/03
Eu sou o único que pensa que misturar xite fitentrar ité difícil de ler e propenso a erros?
B
119

No núcleo desde 2.1 com fite fdescribe.

phil pirozhkov
fonte
1
Quando uso 'fit' e executo meus testes no console usando karma, vejo muitos testes ignorados, mas para ver os erros de teste, preciso rolar para o topo. Quando executo testes sem 'ajuste', não tenho esse problema, pois tenho um resumo de erros na parte inferior. Você sabe como corrigir esse problema?
tytyryty
25

Para quem se deparar com isso, uma abordagem melhor, que você pode configurar a partir do próprio código, é usar este plugin: https://github.com/davemo/jasmine-only

Ele permite que você defina a exclusividade das especificações diretamente no código como este:

describe.only("MySpec", function() { 
  it('function 1', function() { 
    //... 
  }) 

  it.only('function 2', function() { 
    //... 
  }
})
// This won't be run if there are specs using describe.only/ddescribe or it.only/iit
describe("Spec 2", function(){}) 

Houve uma longa discussão para adicionar isso ao núcleo do Jasmine, consulte: https://github.com/pivotal/jasmine/pull/309

Se você estiver usando Jasmine via Karma / Testacular, já deverá ter acesso ddescribe()eiit()

albemuth
fonte
12
+1 para ddescribe e iit ... Essa deve ser a resposta aceita.
Seth Flores
Isso é melhor ... Observe também que a nova sintaxe é fdescribee fit- "f" significa "focado". Veja também jasmine.github.io/2.1/focused_specs.html
Ezekiel Victor
25

Existem algumas maneiras de fazer isso.

Há: recurso Jasmine's Focused Specs (2.2): http://jasmine.github.io/2.2/focused_specs.html

As especificações de foco farão com que sejam as únicas especificações executadas. Qualquer especificação declarada com ajuste é focada.

describe("Focused specs", function() {
  fit("is focused and will run", function() {
    expect(true).toBeTruthy();
  });

  it('is not focused and will not run', function(){
    expect(true).toBeFalsy();
  });
});

No entanto, eu realmente não gosto da ideia de editar meus testes (fit e fdescribe) para executá-los seletivamente. Prefiro usar um corredor de teste como o karma, que pode filtrar os testes usando uma expressão regular.

Aqui está um exemplo usando o grunhido .

$ grunt karma:dev watch --grep=mypattern

Se você estiver usando gulp (que é o meu executor de tarefas favorito), poderá passar argumentos para o gulp-karma executor de com yargs e padrões de correspondência definindo a configuração do karma.

Mais ou menos assim:

var Args = function(yargs) {
  var _match = yargs.m || yargs.match;
  var _file = yargs.f || yargs.file;
  return {
    match: function() { if (_match) { return {args: ['--grep', _match]} } }
  };
}(args.argv);


var Tasks = function() {
  var test = function() {
    return gulp.src(Files.testFiles)
      .pipe(karma({ configFile: 'karma.conf.js', client: Args.match()}))
      .on('error', function(err) { throw err; });
  };

  return {
    test: function() { return test() }
  }
}(Args);

gulp.task('default', ['build'], Tasks.test);

Veja minha essência: https://gist.github.com/rimian/0f9b88266a0f63696f21

Então agora eu posso executar uma única especificação usando a descrição:

Minha execução de teste local: (Executado 1 de 14 (ignorado 13))

gulp -m 'triggers the event when the API returns success'
[20:59:14] Using gulpfile ~/gulpfile.js
[20:59:14] Starting 'clean'...
[20:59:14] Finished 'clean' after 2.25 ms
[20:59:14] Starting 'build'...
[20:59:14] Finished 'build' after 17 ms
[20:59:14] Starting 'default'...
[20:59:14] Starting Karma server...
INFO [karma]: Karma v0.12.31 server started at http://localhost:9876/
INFO [launcher]: Starting browser Chrome
WARN [watcher]: All files matched by "/spec/karma.conf.js" were excluded.
INFO [Chrome 42.0.2311 (Mac OS X 10.10.3)]: Connected on socket hivjQFvQbPdNT5Hje2x2 with id 44705181
Chrome 42.0.2311 (Mac OS X 10.10.3): Executed 1 of 14 (skipped 13) SUCCESS (0.012 secs / 0.009 secs)
[20:59:16] Finished 'default' after 2.08 s

Consulte também: https://github.com/karma-runner/karma-jasmine

Rimian
fonte
Gosto da sua ideia de usar o grunhido para executar seletivamente testes, mas gostaria que a configuração do gulp e do karma fosse mais flexível, mais fácil de estender e mais fácil de entender para esse assunto.
Nocarrier 13/0618
8

Você pode criar todas as suas especificações antecipadamente, mas desativá-las com xdescribee xitaté estar pronto para testá-las.

describe('BuckRogers', function () {
  it('shoots aliens', function () {
    // this will be tested
  });

  xit('rescues women', function () {
    // this won't
  });
});

// this whole function will be ignored
xdescribe('Alien', function () {
  it('dies when shot', function () {
  });
});
Eric Bock
fonte
1

Com o Jasmine independente (2.0.0), no spec_runner.htlm, eu poderia clicar em uma especificação específica e focar nela. Eu deveria ter notado esse recurso anteriormente.

taro
fonte
1

Não é exatamente o que você pediu, mas a adição iittestará apenas essa especificação específica e ignorará todas as outras no arquivo, ddescribefunciona da mesma maneira. Para que você possa se concentrar em uma especificação específica usando iitouddescribe

Filype
fonte
1

Esta é a resposta mais simplificada com um exemplo prático. Mesmo no fdescribe, você pode executar alguns blocos usando-o. f significa foco.

Também em um bloco sem descrição, que é apenas descrição, é possível selecionar apenas blocos específicos, marcando-os como adequados.

Por favor, execute o código abaixo e observe o log do console, leia também os comentários no código. Leia o artigo deste autor também ajuda. https://davidtang.io/2016/01/03/controlling-which-tests-run-in-jasmine.html

 //If you want to run few describe only add f so using focus those describe blocks and it's it block get run

  fdescribe("focus description i get run with all my it blocks ", function() {
    it("1 it in fdescribe get executed", function() {
        console.log("1 it in fdescribe get executed unless no fit within describe");

    });
    it("2 it in fdescribe get executed", function() {
        console.log("2 it in fdescribe get executed unless no fit within describe");

    });
    //but if you and fit in fdescribe block only the fit blocks get executed
    fit("3  only fit blocks in  fdescribe get executed", function() {
        console.log("If there is  a fit   in fdescribe only fit blocks  get executed");

    });
  });

  describe("none description i get skipped with all my it blocks ", function() {
        it("1 it in none describe get skipped", function() {
            console.log("1 it in none describe get skipped");

        });
        it("2 it in none describe get skipped", function() {
            console.log("2 it in none describe get skipped");
        });
//What happen if we had fit in a none fdescribe block will it get run ?   yes  
       fit("3 fit in none describe get executed too eventhough it;s just describe ", function() {
            console.log("3 fit in none describe get executed too");
        }); 
      });
Sameera De Silva
fonte