web-dev-qa-db-fra.com

ScalaTest: affirmer des exceptions dans des futures échoués (non bloquant)

import org.scalatest.{ FlatSpec, Matchers, ParallelTestExecution }
import org.scalatest.concurrent.ScalaFutures
import org.Apache.thrift.TApplicationException

class Test extends FlatSpec with Matchers with ScalaFutures with ParallelTestExecution {
  it should "throw org.Apache.thrift.TApplicationException for invalid Ids" in {
    val future: Future[Response] = ThriftClient.thriftRequest
    whenReady(future) {
      res => {
       intercept[TApplicationException] {
       }
      }
    }
  }
}

Question: Comment pouvez-vous affirmer les échecs attendus dans Futures sans bloquer? Ce qui précède ne fonctionne pas, l'exception est levée avant le bloc intercept.

scalascalatest
46
flavian

Remarque: laisser cette réponse parce que l'OP l'a trouvée utile, mais pour Scala Futures voir l'autre réponse.

C'est un peu passe-partout, mais Waiter de AsyncAssertions:

import org.scalatest.{ FlatSpec, Matchers, ParallelTestExecution }
import org.scalatest.concurrent.{ ScalaFutures, AsyncAssertions, PatienceConfiguration }
import concurrent.Future
import concurrent.ExecutionContext.Implicits._
import util._ 

class Test extends FlatSpec with Matchers with ScalaFutures with ParallelTestExecution with AsyncAssertions {
  it should "throw for invalid Ids" in {
    val f: Future[Int] = new Goof().goof
    val w = new Waiter
    f onComplete {
      case Failure(e) => w(throw e); w.dismiss()
      case Success(_) => w.dismiss()
    }
    intercept[UnsupportedOperationException] {
      w.await
    }
  }
}

donné

import concurrent.Future
import concurrent.ExecutionContext.Implicits._

class Goof {
  def goof(delay: Int = 1): Future[Int] = Future {
    Thread sleep delay * 1000L
    throw new UnsupportedOperationException
  } 
  def goofy(delay: Int = 1): Future[Int] = Future {
    Thread sleep delay * 1000L
    throw new NullPointerException
  } 
  def foog(delay: Int = 1): Future[Int] = Future {
    Thread sleep delay * 1000L
    7
  }
}

En d'autres termes,

class Test extends FlatSpec with Matchers with ScalaFutures with ParallelTestExecution with AsyncAssertions {
  it should "throw for invalid Ids" in {
    val f: Future[Int] = new Goof().goof
    import Helper._
    f.failing[UnsupportedOperationException] 
  }
}

object Helper {
  implicit class Failing[A](val f: Future[A]) extends Assertions with AsyncAssertions {
    def failing[T <: Throwable](implicit m: Manifest[T]) = {
      val w = new Waiter
      f onComplete {
        case Failure(e) => w(throw e); w.dismiss()
        case Success(_) => w.dismiss()
      }
      intercept[T] {
        w.await
      }
    } 
  } 
}

Ou, si vous avez plusieurs futurs et que vous voulez que le premier futur non conforme échoue au test:

trait FailHelper extends Assertions with AsyncAssertions with PatienceConfiguration {
  def failingWith[T <: Throwable : Manifest](fs: Future[_]*)(implicit p: PatienceConfig) {
    val count = new Java.util.concurrent.atomic.AtomicInteger(fs.size)
    val w = new Waiter
    for (f <- fs) f onComplete {
      case Success(i) =>
        w(intercept[T](i))
        println(s"Bad success $i")
        w.dismiss()
      case Failure(e: T) =>
        println(s"Failed $e OK, count ${count.get}")
        w(intercept[T](throw e))
        if (count.decrementAndGet == 0) w.dismiss()
      case Failure(e) =>
        println(s"Failed $e Bad")
        w(intercept[T](throw e))
        w.dismiss()
    }
    w.await()(p)
  }
}

avec usage

class Test extends FlatSpec with Matchers with ScalaFutures with ParallelTestExecution with FailHelper {
  it should "throw for invalid Ids" in {
    val sut = new Goof()
    import sut._

    val patienceConfig = null  // shadow the implicit
    implicit val p = PatienceConfig(timeout = 10 seconds)

    // all should fail this way
    //failingWith[UnsupportedOperationException](goof(), goofy(3), foog(5))
    //failingWith[UnsupportedOperationException](goof(), foog(5))
    failingWith[UnsupportedOperationException](goof(), goof(2), goof(3))
  }
}

Inspiré par cette réponse mal aimée .

14
som-snytt

Je sais que c'est probablement un peu tard, mais ScalaTest fournit cette fonctionnalité prête à l'emploi (je crois depuis la version 2) en mélangeant le trait ScalaFutures, ou en l'utilisant directement dans vos fonctions de test. Voir!

test("some test") {
  val f: Future[Something] = someObject.giveMeAFuture
  ScalaFutures.whenReady(f.failed) { e =>
    e shouldBe a [SomeExceptionType]
  }
}

Ou vous pouvez y effectuer d'autres affirmations. Fondamentalement, si votre avenir n'échoue pas comme prévu, le test échouera. S'il échoue, mais déclenche une exception différente, le test échoue. Agréable et facile! =]

modification effrontée:

Vous pouvez également utiliser cette méthode pour tester tout ce qui renvoie un avenir:

test("some test") {
  val f: Future[Something] = someObject.giveMeAFuture
  ScalaFutures.whenReady(f) { s =>
    // run assertions against the object returned in the future
  }
}
150
Steven Bakhtiari

Cela a également été enterré dans un commentaire, mais le mixage FutureValues ​​de Scalatest vous a couvert.

Utilisez simplement f.failed.futureValue shouldBe an[TApplicationException]

25
easel

ScalaTest 3.0 ajoute versions asynchrones des traits de spécification comme AsyncFreeSpec:

import org.scalatest.{AsyncFlatSpec, Matchers}
import scala.concurrent.Future

class ScratchSpec extends AsyncFlatSpec with Matchers  {

    def thriftRequest = Future { throw new Exception() }

    it should "throw exception" in {
        recoverToSucceededIf[Exception] {
            thriftRequest
        }
    }
}
10
Brian Low

Vous pouvez également essayer ce quelque chose de simple et court

test("some test throwing SQL Exception") {
      val f: Future[Something] = someObject.giveMeAFuture
      recoverToSucceededIf[SQLException](f)
    }
0
Ali

En plus de Brian Low réponse, j'ai trouvé une belle explication pour recoverToSucceededIf. Ceci est disponible dans tous les styles Async (à partir de ScalaTest 3 ):

Les futures échoués peuvent être testés de deux manières: en utilisant recoverToSucceededIf ou recoverToExceptionIf

  • recoverToSucceededIf est utilisé pour affirmer le type de l'exception dans laquelle le futur se termine:
"return UserNotFoundException" when {
       "the user does not exist" in {
         recoverToSucceededIf[UserNotFoundException](userService.findUser("1"))
       }
     }
  • recoverToExceptionIf est utile lorsque vous souhaitez tester certains des champs de l'exception:
"return UserAlreadyExistsException" when {
     "adding a user with existing username" in {
       recoverToExceptionIf[UserAlreadyExistsException] {
         userService.addUser(user)
       }.map { ex =>
         ex.message shouldBe s"User with username: $username already exists!"
       }
     }
   }

Voir le blog entier de Tudor Zgureanu - Quoi de neuf dans ScalaTest

0
pme