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

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?

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.

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):

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"

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.)

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"

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.