So führen Sie eine Überprüfung mit Scala durch (Test)

100

Ich versuche, ScalaTest in mein Java-Projekt zu integrieren. Ersetzen aller JUnit-Tests durch ScalaTests. An einer Stelle möchte ich überprüfen, ob Guices Injector den richtigen Typ injiziert. In Java habe ich einen Test wie diesen:

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

Aber ich habe ein Problem damit, dasselbe mit ScalaTest zu tun:

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

Es wird beanstandet, dass der Wert instanceofkein Mitglied von Door/ Window/ ist Roof. Kann ich instanceofdas in Scala nicht so verwenden ?

Hilfsmethode
quelle

Antworten:

114

Scala ist kein Java. Scala hat einfach nicht den Operator, instanceofsondern eine parametrische Methode namens isInstanceOf[Type].

Sie können sich auch einen ScalaTest-Crashkurs ansehen .

agilesteel
quelle
6
Nun, das beantwortet die Frage nicht wirklich. ScalaTest bietet integrierte Unterstützung für die Typprüfung. Siehe die Antwort von @
martin
Wie geht das, wenn "Typ" ein Merkmal ist?
Lobo
Ich bin mir nicht sicher, ob ich es richtig verstehe, aber es sollte dasselbe sein : isInstanceOf[TraitName].
Agilesteel
88

Mit Scalatest 2.2.x (möglicherweise sogar früher) können Sie Folgendes verwenden:

anInstance mustBe a[SomeClass]
martin-g
quelle
4
Dies ist der empfohlene Ansatz für neuere Versionen von ScalaTests
maasg
6
auch verfügbar, a[Type]damit Sie grammatikalisch korrekt sein können;)
Samuel
Ich habe danach gesucht! :)
Atais
22
tiger shouldBe a [Tiger]ist die aktuelle Syntax scalatest.org/at_a_glance/FlatSpec
jhegedus
2
@jhegedus mustBeist auch korrekt, wenn Sie doc.scalatest.org/3.0.1/#org.scalatest.MustMatchers verwenden, die Sie für FreeSpec möchten.
Tobi
30

Wenn Sie weniger JUnit-artig sein möchten und die ScalaTest-Matcher verwenden möchten, können Sie Ihren eigenen Eigenschafts-Matcher schreiben, der dem Typ entspricht (Löschen des Balkentyps).

Ich fand diesen Thread sehr nützlich: http://groups.google.com/group/scalatest-users/browse_thread/thread/52b75133a5c70786/1440504527566dea?#1440504527566dea

Sie können dann Aussagen schreiben wie:

house.door should be (anInstanceOf[WoodenDoor])

anstatt

assert(house.door instanceof WoodenDoor)
Guillaume Belrose
quelle
+1 Das sieht sehr gut aus und ist für Nicht-Programmierer sogar verständlich (vorausgesetzt, sie wissen, was eine Instanz ist :-)).
Hilfsmethode
Wenn Sie nach Syntaxzucker suchen, können Sie mit einigen Umgestaltungen möglicherweise schreiben, dass house.door (madeOf [Wood]) oder house.door (madeOf [Bamboo]) sein sollte.
Guillaume Belrose
16

Die aktuellen Antworten zu isInstanceOf [Type] und Junit-Ratschlägen sind gut, aber ich möchte eine Sache hinzufügen (für Personen, die diese Seite in einer nicht junit-bezogenen Funktion aufgerufen haben). In vielen Fällen entspricht der Scala-Mustervergleich Ihren Anforderungen. Ich würde es in diesen Fällen empfehlen, da es Ihnen die kostenlose Typisierung ermöglicht und weniger Raum für Fehler lässt.

Beispiel:

OuterType foo = blah
foo match {
  case subFoo : SubType => {
    subFoo.thingSubTypeDoes // no need to cast, use match variable
  }
  case subFoo => {
    // fallthrough code
  }
}
alexbobp
quelle
Die empfohlene Methode zum Testen einer Musterübereinstimmung in ScalaTest ist die Verwendung inside(foo)anstelle von "foo match". Siehe scalatest.org/user_guide/using_matchers#matchingAPattern
Rich Dougherty
3

Konsolidierung von Guillaumes ScalaTest-Diskussionsreferenz (und einer weiteren von James Moore verknüpften Diskussion) in zwei Methoden, die für ScalaTest 2.x und Scala 2.10 aktualisiert wurden (um ClassTag anstelle von Manifest zu verwenden):

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
  )
}
Raman
quelle
2

Ich benutze 2.11.8, um die Behauptung mit Sammlungen zu machen. Die neuere Syntax lautet wie folgt:

val scores: Map[String, Int] = Map("Alice" -> 10, "Bob" -> 3, "Cindy" -> 8)
scores shouldBe a[Map[_, _]] 
aristotll
quelle
3
Aufgrund des Löschvorgangs können Sie die MapTypparameter des Typs nicht überprüfen . Was Sie geschrieben haben, ist dasselbe wie Schreiben scores shouldBe a[Map[_, _]]. Dies wird hier erwähnt: scalatest.org/user_guide/using_matchers#checkingAnObjectsClass
Rich Dougherty