Cómo hacer una instancia de verificación con Scala (prueba)

Estoy intentando incorporar ScalaTest en mi proyecto Java; reemplazando todas las pruebas JUnit con ScalaTests. En un momento, quiero comprobar si el inyector de Guice inyecta el tipo correcto. En Java, tengo una prueba como esta:

public class InjectorBehaviour {
    @Test
    public void shouldInjectCorrectTypes() {
        Injector injector = Guice.createInjector(new ModuleImpl());
        House house = injector.getInstance(House.class);

        assertTrue(house.door() instanceof WoodenDoor);
        assertTrue(house.window() instanceof BambooWindow);
        assertTrue(house.roof() instanceof SlateRoof);
    }
}

Pero tengo un problema para hacer lo mismo con ScalaTest:

class InjectorSpec extends Spec {
    describe("An injector") {
        it("should inject the correct types") {
            val injector = Guice.createInjector(new ModuleImpl)
            val house = injector.getInstance(classOf[House])

            assert(house.door instanceof WoodenDoor)
            assert(house.window instanceof BambooWindow)
            assert(house.roof instanceof SlateRoof)
        }
    }
}

Se queja de que el valor instanceofno es miembro de Door/ Window/ Roof. ¿No puedo usar instanceofesa forma en Scala?

Scala no es Java. Scala simplemente no tiene el operadorinstanceof sino que tiene un método paramétrico llamado isInstanceOf[Type].

También puede disfrutar viendo un curso intensivo ScalaTest .

Con Scalatest 2.2.x (tal vez incluso antes) puede usar:

anInstance mustBe a[SomeClass]

Si desea ser menos JUnit-esque y si desea utilizar los comparadores de ScalaTest, puede escribir su propio comparador de propiedades que coincida con el tipo (borrado de tipo de barra).

Encontré este hilo bastante útil: http://groups.google.com/group/scalatest-users/browse_thread/thread/52b75133a5c70786/1440504527566dea?#1440504527566dea

Luego puede escribir afirmaciones como:

house.door should be (anInstanceOf[WoodenDoor])

en vez de

assert(house.door instanceof WoodenDoor)

Las respuestas actuales sobre isInstanceOf [Type] y junit advice son buenas, pero quiero agregar una cosa (para las personas que llegaron a esta página en una capacidad no relacionada con junit). En muchos casos, la coincidencia de patrones de Scala se adaptará a sus necesidades. Lo recomendaría en esos casos porque te da el encasillado gratis y deja menos margen de error.

Ejemplo:

OuterType foo = blah
foo match {
  case subFoo : SubType => {
    subFoo.thingSubTypeDoes // no need to cast, use match variable
  }
  case subFoo => {
    // fallthrough code
  }
}

Consolidar la referencia de discusión ScalaTest de Guillaume (y otra discusión vinculada por James Moore) en dos métodos, actualizados para ScalaTest 2.xy Scala 2.10 (para usar ClassTag en lugar de manifiesto):

import org.scalatest.matchers._
import scala.reflect._

def ofType[T:ClassTag] = BeMatcher { obj: Any =>
  val cls = classTag[T].runtimeClass
  MatchResult(
    obj.getClass == cls,
    obj.toString + " was not an instance of " + cls.toString,
    obj.toString + " was an instance of " + cls.toString
  )
}

def anInstanceOf[T:ClassTag] = BeMatcher { obj: Any =>
  val cls = classTag[T].runtimeClass
  MatchResult(
    cls.isAssignableFrom(obj.getClass),
    obj.getClass.toString + " was not assignable from " + cls.toString,
    obj.getClass.toString + " was assignable from " + cls.toString
  )
}

Utilizo 2.11.8 para hacer la aserción con colecciones. La sintaxis más nueva es la siguiente:

val scores: Map[String, Int] = Map("Alice" -> 10, "Bob" -> 3, "Cindy" -> 8)
scores shouldBe a[Map[_, _]]