ScalaTest em sbt: existe uma maneira de executar um único teste sem tags?

150

Eu sei que um único teste pode ser executado executando, em sbt,

testOnly *class -- -n Tag

Existe uma maneira de dizer ao sbt / scalatest para executar um único teste sem tags? Por exemplo:

testOnly *class -- -X 2

significaria "executar o segundo teste da classe. Seja o que for". Temos vários testes e ninguém se deu ao trabalho de identificá-los. Existe uma maneira de executar um único teste sem que ele tenha um identificador?

Nacht
fonte
1
Seu assunto diz "Scalatest-sbt". Quando sbt é hifenizado, as pessoas normalmente pensam em um plugin. Mas, apenas para esclarecer, você está falando sobre o uso do ScalaTest a partir de uma versão moderna do sbt como sbt 0.12, não joshcough / scalatest-sbt, um plug-in para o sbt 0.5.2-p3 escrito há 4 anos. Corrigir?
Eugene Yokota
Corrigir. Esta é uma pergunta antiga e, desde então, descobri que não, não é possível (tanto quanto sei). Eu não a fechei caso alguém realmente conseguisse descobrir uma maneira, mas não preciso mais disso para ser respondida.
Nacht
Existe uma discussão sobre isso (com a participação de Bill Venners e Mark Harrah) em groups.google.com/forum/#!topic/scalatest-users/1oRMkudFAXM , mas ainda não há solução
Seth Tisue
1
Há também um caso de suporte geral na execução de um único teste sbt # 911 ( github.com/sbt/sbt/issues/911 ).
Eugene Yokota
14
Note que se você estiver executando a partir da linha de comando, você tem que tudo encerram após o sbtentre aspas , por exemplosbt "test-only *SingleTestSuite"
Chris Martin

Respostas:

202

Agora isso é suportado (desde o ScalaTest 2.1.3) no modo interativo:

testOnly *MySuite -- -z foo

para executar apenas os testes cujo nome inclui a substring "foo".

Para correspondência exata em vez de substring, use em -tvez de -z.

Seth Tisue
fonte
@SethTisue Você seria capaz de postar um exemplo de trabalho usado -tpara a correspondência exata? Não consigo fazê-lo funcionar.
rmin
@rmin gist.github.com/SethTisue/f75cd8b72128ba0a0a81 . (se isso ajuda a resolver o seu problema, deixe-me saber como eu deveria atualizar a minha resposta.)
Seth tisue
10
Só para esclarecer, se você executá-lo a partir da linha de comando, ele deve ser o único argumento: sbt "testOnly * MySuite - foo -z"
Sogartar
2
No caso de alguém quiser executar um teste de integração específica (supostamente colocado sob src/it), eles precisam preceder ita testOnly. Por exemplo, na linha de comando: sbt "it:testOnly *MyIntegrationTestSuite".
laylaylom
2
Como posso filtrar em várias substrings? Os testes podem ser agrupados em uma hierarquia (WordSpec) e as partes do nome separadas por whene should podem se repetir entre os testes. Para escolher um teste específico, preciso dizer "o nome contém isto e aquilo".
Vituel 7/06
98

Eu queria adicionar um exemplo concreto para acompanhar as outras respostas

Você precisa especificar o nome da classe que deseja testar, portanto, se você tiver o seguinte projeto (este é um projeto do Play):

Reproduzir projeto

Você pode testar apenas os Logintestes executando o seguinte comando no console do SBT:

test:testOnly *LoginServiceSpec

Se você estiver executando o comando fora do console do SBT, faça o seguinte:

sbt "test:testOnly *LoginServiceSpec"
Tyler
fonte
27
Upvote porque aparentemente as aspas são necessárias:sbt "test:testOnly *LoginServiceSpec"
Jason Wheeler
5
Resposta mais útil para mim aqui. 👍 Mas os comandos podem ser um pouco simplificados; no console do SBT: testOnly *LoginServiceSpece fora:sbt "testOnly *LoginServiceSpec"
Jonik 17/10
49

Não vejo uma maneira de executar um único teste não marcado dentro de uma classe de teste, mas estou fornecendo meu fluxo de trabalho, pois parece útil para qualquer pessoa que se deparar com essa pergunta.

De dentro de uma sessão sbt:

test:testOnly *YourTestClass

(O asterisco é um curinga, você pode especificar o caminho completo com.example.specs.YourTestClass.)

Todos os testes nessa classe de teste serão executados. Presumivelmente, você está mais preocupado com falhas nos testes, portanto, corrija quaisquer implementações com falha e execute:

test:testQuick

... que executará apenas testes que falharam. (Repetir o test:testOnlycomando executado mais recentemente será o mesmo que test:testQuickneste caso, mas se você dividir seus métodos de teste em classes de teste apropriadas, poderá usar um curinga para criar test:testQuickuma maneira mais eficiente de executar novamente os testes com falha.)

Observe que a nomenclatura para teste no ScalaTest é uma classe de teste, não um método de teste específico; portanto, todos os métodos sem marcação são executados.

Se você tiver muitos métodos de teste em uma classe de teste, divida-os em classes separadas ou identifique-os adequadamente. (Isso pode ser um sinal de que a classe em teste está violando o princípio de responsabilidade única e pode usar uma refatoração.)

cfeduke
fonte
10
para quem está enfrentando "Nenhum teste foi executado": *YourTestClassdeve ser o nome da classe. Não é o nome do arquivo.
precisa saber é o seguinte
1
foi testOnly em vez de somente teste para mim.
Jan Clemens Stoffregen 26/03
11

Apenas para simplificar o exemplo de Tyler.

test:-prefix não é necessário.

Então, de acordo com o exemplo dele:

No sbtconsole:

testOnly *LoginServiceSpec

E no terminal:

sbt "testOnly *LoginServiceSpec"
pme
fonte
0

Aqui está a página do Scalatest sobre o uso do corredor e a discussão estendida sobre as opções -te-z .

Esta postagem mostra quais comandos funcionam para um arquivo de teste que usa FunSpec.

Aqui está o arquivo de teste:

package com.github.mrpowers.scalatest.example

import org.scalatest.FunSpec

class CardiBSpec extends FunSpec {

  describe("realName") {

    it("returns her birth name") {
      assert(CardiB.realName() === "Belcalis Almanzar")
    }

  }

  describe("iLike") {

    it("works with a single argument") {
      assert(CardiB.iLike("dollars") === "I like dollars")
    }

    it("works with multiple arguments") {
      assert(CardiB.iLike("dollars", "diamonds") === "I like dollars, diamonds")
    }

    it("throws an error if an integer argument is supplied") {
      assertThrows[java.lang.IllegalArgumentException]{
        CardiB.iLike()
      }
    }

    it("does not compile with integer arguments") {
      assertDoesNotCompile("""CardiB.iLike(1, 2, 3)""")
    }

  }

}

Este comando executa os quatro testes no iLikebloco de descrição (na linha de comando do SBT):

testOnly *CardiBSpec -- -z iLike

Você também pode usar aspas, assim também funcionará:

testOnly *CardiBSpec -- -z "iLike"

Isso executará um único teste:

testOnly *CardiBSpec -- -z "works with multiple arguments"

Isso executará os dois testes que começam com "funciona com":

testOnly *CardiBSpec -- -z "works with"

Não consigo a -topção de executar nenhum teste no CardiBSpecarquivo. Este comando não executa nenhum teste:

testOnly *CardiBSpec -- -t "works with multiple arguments"

Parece que a -topção funciona quando os testes não são aninhados em describeblocos. Vamos dar uma olhada em outro arquivo de teste:

class CalculatorSpec extends FunSpec {
  it("adds two numbers") {
    assert(Calculator.addNumbers(3, 4) === 7)
  }
}

-t pode ser usado para executar o único teste:

testOnly *CalculatorSpec -- -t "adds two numbers"

-z também pode ser usado para executar o teste único:

testOnly *CalculatorSpec -- -z "adds two numbers"

Consulte este repositório se desejar executar esses exemplos.

Poderes
fonte