Come eseguire un'istanza di controllo con Scala (Test)

Sto cercando di incorporare ScalaTest nel mio progetto Java; sostituire tutti i test JUnit con ScalaTests. A un certo punto, voglio controllare se l'iniettore di Guice inietta il tipo corretto. In Java, ho un test come questo:

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);
    }
}

Ma ho un problema a fare lo stesso 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)
        }
    }
}

Si lamenta che il valore instanceofnon è un membro di Door/ Window/ Roof. Non posso usare in instanceofquesto modo in Scala?

Scala non è Java. Scala semplicemente non ha l'operatore, instanceofinvece ha un metodo parametrico chiamato isInstanceOf[Type].

Potresti anche divertirti guardando un corso intensivo ScalaTest .

Con Scalatest 2.2.x (forse anche prima) puoi usare:

anInstance mustBe a[SomeClass]

Se vuoi essere meno JUnit-esque e se vuoi usare i matcher di ScalaTest, puoi scrivere il tuo abbinatore di proprietà che corrisponde al tipo (cancellazione del tipo di barra).

Ho trovato questo thread molto utile: http://groups.google.com/group/scalatest-users/browse_thread/thread/52b75133a5c70786/1440504527566dea?#1440504527566dea

Puoi quindi scrivere affermazioni come:

house.door should be (anInstanceOf[WoodenDoor])

invece di

assert(house.door instanceof WoodenDoor)

Le attuali risposte sui consigli isInstanceOf [Type] e junit sono buone ma voglio aggiungere una cosa (per le persone che sono arrivate a questa pagina in veste non correlata a junit). In molti casi, la corrispondenza del modello scala si adatta alle tue esigenze. Lo consiglierei in quei casi perché ti dà il typecasting gratuitamente e lascia meno spazio per errori.

Esempio:

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

Consolidamento del riferimento alla discussione ScalaTest di Guillaume (e un'altra discussione collegata a James Moore) in due metodi, aggiornati per ScalaTest 2.x e Scala 2.10 (per utilizzare ClassTag anziché manifest):

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

Uso 2.11.8 per fare l'asserzione con le raccolte. La sintassi più recente è la seguente:

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