В чем разница между ScalaTest и Scala Specs unit test Framework?

оба являются BDD (Behavior Driven Development) способными платформами модульного тестирования для Scala, написанными на Scala. И технические характеристикипостроен может также включать ScalaTest основы. Но то, что спецификации предлагают ScalaTest не делает? В чем же разница?

6 114
scala string-comparison unit-testing scalatest

6 ответов:

спецификации и ScalaTest-это хорошие инструменты для счастливых пользователей, но они отличаются несколькими способами. Вы, вероятно, захотите выбрать один в качестве основного инструмента тестирования в Scala, но не нужно отказываться от другого, потому что вы можете использовать части обоих. Если вам нравится ScalaTest-это FeatureSpec синтаксис и синтаксис спецификации Mockito, например, вы можете поместить оба файла jar в свой путь к классам и использовать оба одновременно. Здесь я попытаюсь захватить основные различия в философии дизайна, которые я заметил между спецификациями и ScalaTest.

ScalaTest поддерживает BDD через его Spec,FeatureSpec,WordSpec,FlatSpec, и GivenWhenThen черты, а также имеет черты, которые вы можете смешать, чтобы получить хороший синтаксис сопоставления. Если вам нравится "должен", вы смешиваете в ShouldMatchers. Если вам нравится "должен", вы смешиваете в MustMatchers. Но если вам нравится BDD, но не нравится синтаксис matcher, вы можете просто использовать одну из особенностей спецификации ScalaTest без смешивания в черте matchers. Specs имеет класс спецификации, который вы расширяете, и вы должны использовать слово "должен" в своих выражениях сопоставления. Большая философская разница, которая здесь очевидна, заключается в том, что ScalaTest дает у тебя гораздо больше вариантов. Чтобы сделать это пространство выбора легче ориентироваться, я предоставляю дерево решений здесь:

http://www.scalatest.org/quick_start

синтаксис сопоставления также отличается между ScalaTest и спецификациями. В ScalaTest я попытался понять, как далеко я могу пойти с операторной нотацией, и в конечном итоге получил выражения matcher, которые очень похожи на английские предложения, с пробелами между словами. Технические характеристики синтаксических совпадений слов работает вместе с дело верблюда.

спецификации имеют больше сопоставителей, чем ScalaTest, и это, я думаю, отражает разницу в отношении к дизайну. Я фактически сократил, вероятно, 2/3 синтаксиса matcher, который я построил и рассмотрел для выпуска. Я добавлю больше matchers в будущих версиях, но хотел быть уверен, что я знал, что пользователи на самом деле хотели что-то, прежде чем я добавил его. Однако сопоставители ScalaTest включают в себя динамический синтаксис сопоставления свойств, который занимает часть этого провала. Например в спецификациях вы можете написать на a java.io.File:

file must beDirectory

появится isDirectory и убедитесь, что это правда. ScalaTest не имеет никаких специальных сопоставителей для java.io.Files в настоящее время, но в ScalaTest, вы можете просто использовать динамическую проверку следующим образом:

file must be a ('directory)

каждый раз, когда вы передаете символ после be он будет использовать отражение, чтобы искать (в данном случае) метод или поле с именем directory или метод с именем isDirectory. Есть также способ сделать эту статику, определив BePropertyMatcher (которая требует только 2 или 3 строки кода обычно). Поэтому в основном в ScalaTest я стараюсь обеспечить больше функциональности с меньшим API.

еще одна общая разница в отношении дизайна между спецификациями и ScalaTest включает неявные преобразования. По умолчанию вы получаете только одно неявное преобразование при использовании ScalaTest, который ставит === оператор на все. (Если вам нужно, вы можете "выключить" это неявное преобразование с помощью одной строки кода. Единственная причина, по которой вам нужно это сделать это если вы пытались проверить что-то, что имеет свой собственный === оператор, и вы получаете конфликт.) ScalaTest определяет многие другие неявные преобразования, но для их использования вам нужно явно "пригласить" их в свой код, смешивая в чертеже или делая импорт. Когда вы расширяете класс Specification в спецификациях я думаю, что вы в значительной степени получаете десятки неявных преобразований по умолчанию. Я не уверен, насколько это будет иметь значение на практике, но я думаю, что люди захотят протестировать код, который использует их собственный неявные преобразования, и иногда может быть конфликт между неявные преобразования в рамках испытания и производственный код. Когда это происходит, я думаю, что это может быть проще обойти проблему в ScalaTest, чем спецификации.

еще одна разница в отношении к дизайну, которую я заметил, - это комфорт с операторами. Одна из моих целей заключалась в том, что любой программист, смотрящий на чужой тестовый код, который использует ScalaTest, сможет угадать, что это значит, не глядя ничего в Масштабная документация. Я хотел, чтобы ScalaTest клиентский код был совершенно очевидным. Один из способов, которым эта цель проявилась, заключается в том, что ScalaTest очень консервативен в отношении операторов. Я определяю только пять операторов в ScalaTest:

  • ===, что означает, что равна
  • >, что означает больше, чем
  • <, меньше
  • >=, больше или равно
  • <=, меньше или равный.

вот и все. Так что эти вещи в значительной степени похожи на то, что означает. Если вы видите в чужом коде:

result should be <= 7

я надеюсь, что вам не нужно будет запускать документацию API, чтобы угадать, что это <= средства. В отличие от этого, спецификации намного свободнее с операторами. В этом нет ничего плохого, но есть разница. Операторы могут сделать код более сжатым, но компромисс заключается в том, что вам может потребоваться запустить документацию, когда вы найдете такие вещи, как ->-, >>,|,|>,! или ^^^ (которые все имеют специальные значения в спецификациях) в тестовом коде вашего коллеги.

еще одно философское различие заключается в том, что я стараюсь немного облегчить в ScalaTest использование функционального стиля, когда вам нужно поделиться приспособлением, тогда как спецификации по умолчанию продолжают традицию setUp и tearDown подход популяризирован JUnit, в котором вы переназначаете vars перед каждым тестом. Однако, если вы хотите проверить это кстати, это также очень легко в ScalaTest. Вам просто нужно смешать в BeforeAndAfter черта.

для более глубокого понимания ScalaTest вы можете посмотреть презентацию" Get Higher with ScalaTest", которую я дал на конференции Devoxx 2009 здесь:

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

165

основные различия (в основном с точки зрения спецификаций: -)):

  • ScalaTest предоставляет больше "стилей тестирования", чем спецификации (вы можете посетить каждую точку маркера на быстрый старт страница для получения подробного представления о каждом стиле)

  • ScalaTest и спецификации имеют другой набор сопоставителей. Вы можете сравнить их здесь для ScalaTest и здесь для спецификаций. С этой стороны вещей, спецификации имеет много небольшие функции, которые могут вам понравиться при написании спецификации: xml-сопоставители, композиция сопоставителей (простой способ повторного использования сопоставителей путем их преобразования), точные сбои, подробные различия для длинных строк,...

  • Mockito получил хорошую поддержку BDD в спецификациях:Mockito

  • технические характеристики имеет DataTables которые позволяют группировать много небольших примеров в виде таблицы (если вы можете стоять операторы используются как разделители таблицы)

  • в спецификациях вы можете определить примеры, которые вложены как libidum и автоматически очищен на каждом уровне

Это, конечно, очень частичное и предвзятое сравнение, и существует много других различий (и библиотеки все еще развиваются, ...).

в конце концов, я думаю, что это действительно зависит от вашего тестирования/определения стиля. Если это просто (простая спецификация структура, установки, ожидания ...) тогда обе библиотеки окажутся очень похожими. В противном случае, оба имеют свое мнение о том, как все должно быть сделано. В качестве последнего примера этого вы можете посмотреть на тегирование: in ScalaTest и технические характеристики.

Я надеюсь, что это помогает.

46

насколько я знаю, за исключением нескольких весьма специализированных функций, это сводится к личным предпочтениям по стилю.

4

поддержка IDE может быть другой точкой

Я пытался получить спецификации для работы с Eclipse через JUnit, и я нашел официальное решение немного "хаки". Настройка спецификаций: http://code.google.com/p/specs/wiki/RunningSpecs#Run_your_specification_with_JUnit4_in_Eclipse

интеграция ScalaTest (также через JUnit) с кажется немного менее хаки. Тем не менее, у меня нет ни одного из них, чтобы работать, а также JUnit и Java.

настройка ScalaTest: http://groups.google.com/group/scalatest-users/web/running-scalatest-from-eclipse

2

Если один фактор решения-это время компиляции,scalatest, кажется, работает лучше.

в настоящее время мы используем specs2 в нашем проекте, но страдаем от медленного времени компиляции в тестах. Я только что закончил POC при переходе к scalatest и увидел, что время компиляции упало примерно в 0,82 раза, просто переключив 2 фреймворка в некоторых наших источниках.

0

основные различия между ScalaTest и Specs2 являются:

  • общая структура теста в Specs2 отличается от той, что в ScalaTest.
  • Specs2 имеет другой набор Сопоставителей с другим синтаксисом.
  • тесты Specs2 в основном, посвящены разработка на основе поведения (BDD), в то время как ScalaTest тесты являются более общими.
  • ScalaTest обеспечивает гораздо больше выбора и универсальности. Например, написать BDD-like Specs2 в ScalaTest, можно использовать Spec, FeatureSpec, WordSpec,FlatSpecи GivenWhenThen черт вместе с ShouldMatchers или MustMatcher. Это дает разработчику больше гибкости, чтобы следовать его / ее собственный стиль написания спецификаций.

  • Specs2 имеет значительно большее количество Сопоставителей, чем ScalaTest. Большинство из них предназначены для особых нужд. Для например, в Specs2, вы можете сказать:

    aFile должен быть aDirectory

  • где Specs2 имеет отдельные Сопоставители для java.io.Files, ScalaTest не имеет подобных Сопоставителей.

  • еще одно различие между ScalaTest и Spec-неявные преобразования. ScalaTest имеет только одно неявное преобразование, которое мы достигаем с помощью === оператора. Однако это можно отключить в ScalaTest, используя одну строку код. Это единственное неявное преобразование получить бесплатно в ScalaTest. Существуют и другие неявные преобразования, которые могут быть использованы при смешивании других признаков. В отличие от этого Specs2gives вам десятки неявного преобразования просто путем расширения спецификация класса. На практике это не имеет большого значения. Единственное различие заключается в том, что тестовый код будет более читаемым без явных преобразований.

  • Specs2 имеет таблицы данных. Это позволяет использование ряда примеров, которые могут управлять тестом, подобно тестам, управляемым свойствами.

  • тесты Specs2 отличаются от ScalaTest тем, что они могут выполняться одновременно в отдельном потоке.

0