ScalaTest en sbt: ¿hay alguna manera de ejecutar una sola prueba sin etiquetas?

Sé que se puede ejecutar una sola prueba ejecutando, en SBT,

testOnly *class -- -n Tag

¿Hay alguna manera de decirle a sbt / scalatest que ejecute una sola prueba sin etiquetas? Por ejemplo:

testOnly *class -- -X 2

significaría "ejecutar la segunda prueba en la clase. Sea lo que sea". Tenemos un montón de pruebas y nadie se molestó en etiquetarlas, entonces, ¿hay alguna forma de ejecutar una sola prueba sin que tenga una etiqueta?

Esto ahora es compatible (desde ScalaTest 2.1.3) dentro del modo interactivo:

testOnly *MySuite -- -z foo

ejecutar solo las pruebas cuyo nombre incluye la subcadena "foo".

Para una coincidencia exacta en lugar de una subcadena, use en -tlugar de -z.

Quería agregar un ejemplo concreto para acompañar las otras respuestas

Debe especificar el nombre de la clase que desea probar, por lo que si tiene el siguiente proyecto (este es un proyecto de Play):

Puede probar solo las Loginpruebas ejecutando el siguiente comando desde la consola SBT:

test:testOnly *LoginServiceSpec

Si está ejecutando el comando desde fuera de la consola SBT, haría lo siguiente:

sbt "test:testOnly *LoginServiceSpec"

No veo una manera de ejecutar una sola prueba sin etiquetar dentro de una clase de prueba, pero estoy proporcionando mi flujo de trabajo, ya que parece ser útil para cualquiera que se encuentre con esta pregunta.

Desde una sesión de sbt:

test:testOnly *YourTestClass

(El asterisco es un comodín, puede especificar la ruta completa com.example.specs.YourTestClass).

Se ejecutarán todas las pruebas dentro de esa clase de prueba. Presumiblemente, usted está más preocupado por las pruebas fallidas, corrija las implementaciones fallidas y luego ejecute:

test:testQuick

... que solo ejecutará pruebas que fallaron. (Repetir el test:testOnlycomando ejecutado más recientemente será el mismo que test:testQuicken este caso, pero si divide sus métodos de prueba en clases de prueba apropiadas, puede usar un comodín para hacer test:testQuickuna forma más eficiente de volver a ejecutar las pruebas fallidas).

Tenga en cuenta que la nomenclatura para la prueba en ScalaTest es una clase de prueba, no un método de prueba específico, por lo que se ejecutan todos los métodos sin etiquetar.

Si tiene demasiados métodos de prueba en una clase de prueba, divídalos en clases separadas o márquelos adecuadamente. (Esto podría ser una señal de que la clase bajo prueba está violando el principio de responsabilidad única y podría usar una refactorización).

Solo para simplificar el ejemplo de Tyler.

test:-prefijo no es necesario.

Entonces según su ejemplo:

En la sbtconsola:

testOnly *LoginServiceSpec

Y en la terminal:

sbt "testOnly *LoginServiceSpec"

Aquí está la página Scalatest sobre el uso del corredor y la discusión extendida sobre las opciones -ty-z .

Esta publicación muestra qué comandos funcionan para un archivo de prueba que utiliza FunSpec.

Aquí está el archivo de prueba:

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 ejecuta las cuatro pruebas en el iLikebloque describe (desde la línea de comando SBT):

testOnly *CardiBSpec -- -z iLike

También puede usar comillas, por lo que esto también funcionará:

testOnly *CardiBSpec -- -z "iLike"

Esto ejecutará una sola prueba:

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

Esto ejecutará las dos pruebas que comienzan con "funciona con":

testOnly *CardiBSpec -- -z "works with"

No puedo obtener la -topción de ejecutar ninguna prueba en el CardiBSpecarchivo. Este comando no ejecuta ninguna prueba:

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

Parece que la -topción funciona cuando las pruebas no están anidadas en describebloques. Echemos un vistazo a otro archivo de prueba:

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

-t se puede usar para ejecutar la prueba individual:

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

-z También se puede utilizar para ejecutar la prueba única:

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

Consulte este repositorio si desea ejecutar estos ejemplos.