Quelle est la différence entre ScalaTest et Scala Specs cadres de tests unitaires?

Question

sont deux BDD (Comportement Driven Development) des cadres de tests unitaires capables de Scala écrit en Scala. Et Specs est construit sur peut également impliquer le ScalaTest cadre . Mais qu'est-ce que Spéc offre ScalaTest ne fonctionne pas? Quelles sont les différences?

Answer 1

Caractéristiques et ScalaTest sont tous deux bons outils avec les utilisateurs heureux, mais ils diffèrent de plusieurs façons. Vous voudrez probablement choisir un comme outil de test principal Scala, mais n'a pas besoin d'abandonner l'autre parce que vous pouvez utiliser des morceaux de deux. Si vous aimez la syntaxe de FeatureSpec de ScalaTest et la syntaxe Mockito de spécifications, par exemple, vous pouvez mettre les deux fichiers jar dans votre classpath et utiliser les deux en même temps. Ici, je vais essayer de capturer les principales différences de philosophie de la conception que j'ai remarqué entre les spécifications et ScalaTest.

Probablement la principale différence philosophique entre les outils est que les spécifications est conçu pour le développement de comportement oriented (BDD), alors que ScalaTest est plus générale. ScalaTest fournit des traits que vous pouvez mélanger ensemble pour obtenir le comportement que vous préférez dans vos classes de test, y compris BDD, et vous pouvez également définir facilement votre propre comportement si vous voulez quelque chose de différent.

ScalaTest soutient BDD par ses Spec, FeatureSpec, WordSpec, FlatSpec et traits de GivenWhenThen, et a aussi des traits que vous pouvez mélanger pour obtenir une belle syntaxe matcher. Si vous aimez « devrait », vous mélanger ShouldMatchers. Si vous aimez « devez », vous mélanger MustMatchers. Mais si vous aimez BDD mais n'aimez pas la syntaxe de matcher, vous pouvez simplement utiliser l'un des traits Spec ScalaTest sans se mélanger dans un trait de matchers. Specs a une classe de spécification que vous étendez, et vous devez utiliser le mot « must » dans vos expressions de matcher. Une grande différence philosophique qui est évident ici que ScalaTest vous donne beaucoup plus de choix. Pour cet espace de choix plus facile à naviguer, je fournis un arbre de décision ici:

http://www.scalatest.org/quick_start

La syntaxe de matcher est également différente entre ScalaTest et spécifications. En ScalaTest j'ai essayé de voir jusqu'où je pourrais aller avec la notation de l'opérateur, et a fini avec des expressions de matcher qui lisent beaucoup comme phrases en anglais, avec des espaces entre les mots. Spécifications matcher syntaxe fonctionne plus avec des mots ainsi que le cas de chameau.

Caractéristiques a plus matchers que ScalaTest, et que je pense que reflète une différence d'attitude de conception. En fait, je coupe probablement 2/3 de la syntaxe matcher I construit et envisager une diffusion. Je vais ajouter plus matchers dans les prochaines versions, mais je voulais être sûr que je savais que les utilisateurs voulaient vraiment quelque chose avant je l'ai ajouté. Cependant les matchers de ScalaTest comprend une syntaxe matcher de propriété dynamique prend une partie de ce jeu. Par exemple dans les specs, vous pouvez écrire sur un java.io.File:

file must beDirectory

invoquera la isDirectory et assurez-vous qu'il est vrai. ScalaTest n'a pas de matchers spéciales pour java.io.Files actuellement, mais ScalaTest, vous pouvez simplement utiliser un contrôle dynamique comme ceci:

file must be a ('directory)

Chaque fois que vous passez un symbole après be, il utilisera la réflexion pour chercher (dans ce cas) un procédé ou d'un champ nommé directory ou une méthode nommée isDirectory. Il y a aussi un moyen de rendre cette statique, en définissant un BePropertyMatcher (qui ne nécessite que 2 ou 3 lignes de code en général). Donc, fondamentalement, dans ScalaTest je tente de fournir plus de fonctionnalités avec moins API.

Une autre différence d'attitude de conception générale entre les spécifications et ScalaTest implique des conversions implicites. Par défaut, vous obtenez seulement une conversion implicite lorsque vous utilisez ScalaTest, qui est celui qui met l'opérateur === sur tout. (Si vous avez besoin, vous pouvez « désactiver » cette conversion implicite avec une ligne de code. La seule raison pour laquelle vous devez faire est si vous essayez de tester quelque chose qui a son propre opérateur ===, et vous obtenez un conflit .) ScalaTest définit beaucoup d'autres conversions implicites, mais de les utiliser, vous devez les « inviter » explicitement dans votre code en mélangeant dans un trait ou de faire une importation. Lorsque vous étendez la classe Specification dans les specs je pense que vous obtenez à peu près des dizaines de conversions implicites par défaut. Je ne sais pas combien cela la matière dans la pratique, mais je figure les gens veulent tester le code qui utilise leurs propres implicits, et parfois il peut y avoir un conflit entre les implicits du cadre d'essai et celles du code de production. Quand cela arrive, je pense qu'il peut être plus facile de contourner le problème en ScalaTest que les spécifications.

Une autre différence d'attitude de la conception que je l'ai remarqué est le confort des opérateurs. L'un des objectifs que j'avais était que tout programmeur regardant quelqu'un code de test d'autre qui utilise ScalaTest serait en mesure de deviner ce que le sens était sans regarder quoi que ce soit dans la documentation ScalaTest. Je voulais code client ScalaTest à tomber raide mort évidente. Une façon cet objectif manifeste lui-même est que ScalaTest est très prudent sur les opérateurs. Je ne définis cinq opérateurs ScalaTest:

• ===, ce qui signifie égal à égal
• >, ce qui signifie plus grand que
• <, moins de
• >=, supérieur ou égal
• <=, inférieur ou égal.

Voilà. Donc, ces jolies choses ressemblent beaucoup à ce que signifie. Si vous voyez dans le code de quelqu'un d'autre:

result should be <= 7

Mon espoir est que vous aurez pas besoin de courir à la documentation de l'API pour deviner ce qui signifie <=. En revanche, les spécifications est beaucoup plus libre avec les opérateurs. Rien de mal à cela, mais il y a une différence. Les opérateurs peuvent rendre le code plus concis, mais le compromis est que vous pouvez avoir à courir à la documentation lorsque vous trouvez des choses comme ->-, >>, |, |>, ! ou ^^^ (qui tous ont une signification particulière dans les specs) dans le code de test de votre collègue .

Une autre différence philosophique est que je n'essayer de faire juste un peu plus facile à ScalaTest d'utiliser un style fonctionnel lorsque vous avez besoin de partager un appareil, alors que Spéc par défaut continue la tradition de l'approche setUp et tearDown popularisé par JUnit, dans lequel vous réattribuer vars avant chaque test. Toutefois, si vous voulez tester cette façon, il est également très facile à ScalaTest. Vous avez juste besoin de mélanger le trait BeforeAndAfter.

Pour plus de perspicacité dans ScalaTest, vous pouvez regarder la présentation que j'ai donné à la conférence Devoxx 2009 « Get Higher avec ScalaTest » ici:

http://parleys.com/play/514892260364bc17fc56bde3/chapter0/about

Answer 2

Les principales différences sont (la plupart du temps d'un point de vue caractéristiques :-)):

• ScalaTest fournit plus « styles de test » que les spécifications (vous pouvez visiter chaque puce sur le démarrage rapide la page pour obtenir une vue détaillée sur chaque style)

• ScalaTest et les spécifications ont un ensemble différent de matchers. Vous pouvez les comparer pour ScalaTest et < a href = "http://code.google.com/p/specs/wiki/MatchersGuide" rel = "noreferrer"> ici pour les spécifications. De ce côté des choses, spécifications a beaucoup de petites fonctionnalités que vous aimeriez lors de l'écriture de votre cahier des charges: matchers xml, composition Matchers (un moyen facile de réutiliser matchers en les transformant), des défaillances précises, les différences détaillées pour les longues chaînes, .. .

• Mockito a été donné un beau soutien BDD dans les specs: Mockito

• DataTables qui permettent de regrouper beaucoup de petit exemple dans une sorte de table (si vous pouvez supporter les opérateurs utilisés comme délimiteurs de table)

• Dans les spécifications, vous pouvez définir des exemples qui sont imbriqués comme libitum et automatiquement-up nettoyé à tous les niveaux

Ceci est certainement une très comparaison partielle et partiale et bien d'autres différences existent (et les bibliothèques évoluent encore, ...).

A la fin de la journée, je pense que cela dépend vraiment de vos tests / style spécification. Si c'est simple (structure simple de spécifications, les configurations, les attentes, ...), les deux bibliothèques apparaissent très similaires. Dans le cas contraire, les deux ont leur point de vue sur la façon dont les choses devraient se faire. En dernier exemple de ce que vous pouvez jeter un oeil à l'étiquetage: ScalaTest et spécifications .

J'espère que cette aide.

Answer 3

Pour autant que je sache, sauf quelques fonctionnalités très spécialisées, il est question de préférence personnelle selon le style.

Answer 4

support IDE peut être un autre point

J'ai essayé d'obtenir specs pour travailler avec Eclipse à travers JUnit, et j'ai trouvé la solution officielle d'être un peu « aki ». Configuration des spécifications: http://code.google.com/p/specs/wiki / RunningSpecs # Run_your_specification_with_JUnit4_in_Eclipse

L'intégration de ScalaTest (aussi par JUnit) avec semble un peu moins aki. Pourtant, je n'ai aucun d'entre eux de travailler ainsi que JUnit et Java.

Mise en ScalaTest: http: // groupes. google.com/group/scalatest-users/web/running-scalatest-from-eclipse

Answer 5

Si un facteur de décision est le moment de la compilation, scalatest semble mieux performer.

Nous utilisons actuellement specs2 dans notre projet, mais souffrent de la compilation lente fois dans les tests. Je viens de terminer un POC sur le déplacement à scalatest et vu les temps de compilation baisse d'un facteur d'environ 0,82 simplement en changeant les 2 cadres dans certains de nos sources.