Сравнение между Mockito и JMockit - почему Моккито проголосовал лучше, чем JMockit?

Ответ 1

Я бы сказал, что конкурс между JMockit и PowerMock, затем Mockito.

Я оставил бы "простой" jMock и EasyMock, потому что они используют только прокси и CGLIB и не используют инструменты Java 5, как более новые рамки.

jMock также не имел стабильного выпуска более 4 лет. jMock 2.6.0 потребовалось 2 года, чтобы перейти от RC1 к RC2, а затем еще 2 года, прежде чем он действительно был выпущен.

Относительно прокси и CGLIB против инструментария:

(EasyMock и jMock) основаны на java.lang.reflect.Proxy, который требует, чтобы интерфейс был реализованы. Кроме того, они поддерживать создание макетных объектов для классов через подкласс CGLIB поколение. Из-за этого, сказал классы не могут быть окончательными и только методы переопределяемого экземпляра могут быть издевались. Самое главное, однако, при использовании этих инструментов зависимости тестируемого кода (что есть, объекты других классов на который испытывает данный класс зависит) должны контролироваться тестов, так что ложные экземпляры могут быть переданы клиентам этих зависимостей. Следовательно, зависимости нельзя просто создать с помощью новый оператор в классе клиента для которые мы хотим записать модульные тесты.

В конечном счете технические ограничения обычных издевательских инструментов следующие конструктивные ограничения на производственный код:

• Каждый класс, который, возможно, должен быть изделен в тесте, должен либо реализовать отдельный интерфейс или не быть окончательным.
• Зависимости каждого тестируемого класса должны быть либо получены через настраиваемое создание экземпляра методы (фабрики или службы Locator), или быть выставленным для зависимости инъекции. В противном случае модульные тесты не будут иметь возможность передавать макетные реализации зависимостей от единицы тест.
• Так как только методы экземпляра можно издеваться, классы, подлежащие тестированию на единицу не может вызывать статические методы их зависимостей и они используют любой из конструкторов.

Вышеуказанное копируется из http://jmockit.org/about.html. Кроме того, он сравнивает себя (JMockit), PowerMock и Mockito несколькими способами:

В настоящее время существуют другие инструменты для издевательств Java, которая также ограничения обычных, между ними PowerMock, jEasyTest и MockInject. Тот, который приближается к набору функций JMockit PowerMock, поэтому я вкратце это здесь (кроме того, два других более ограничены и не кажутся активно развиваются).

JMockit vs PowerMock

• Прежде всего, PowerMock не предоставляет полный API для издевательств, но вместо этого работает как расширение другой инструмент, который в настоящее время может быть EasyMock или Mockito. Это очевидно преимущество для существующих пользователей эти инструменты.
• JMockit, с другой стороны, предоставляет совершенно новые API, хотя его основной API (Ожидания) аналогичен как для EasyMock, так и для jMock. Хотя это создает более длинную кривую обучения, она также позволяет JMockit предоставлять проще, более последовательно и проще для использования API.
• По сравнению с API JMockit Expectations API PowerMock более "низкий уровень", заставляя пользователей выяснить и указать, какие классы необходимо подготовить для тестирования (с @PrepareForTest ({ClassA.class,...}) и требует конкретные вызовы API для решения различные типы языковых конструкций которые могут присутствовать в производстве код: статические методы (MockStatic (ClassA.class)), конструкторы (Подавить (конструктор (ClassXyz.class))), вызовы конструктора (expectNew (AClass.class)), частичный mocks (createPartialMock (ClassX.class, "methodToMock" )) и т.д.
• С ожиданием JMockit, все виды методов и конструкторов издевательствовали чисто декларативным образом, с частичным насмешкой, указанным через регулярные выражения в @Mocked аннотации или просто "не издеваясь", участники без записи ожидания; то есть разработчик просто объявляет некоторые общие "макеты" поля "для тестового класса или некоторые" локальные ложные поля "и/или" макет "параметры" для индивидуального теста методов (и в этом последнем случае @Помещенная аннотация часто не будет необходимо).
• Некоторые возможности, доступные в JMockit, такие как поддержка насмешек equals и hashCode, переопределены методы и другие, в настоящее время не поддерживается в PowerMock. Кроме того, существует нет эквивалента способности JMockit к экземпляры захвата и макет реализации указанной базы типов при выполнении теста без сам тестовый код знания о фактической реализации классы.
• PowerMock использует пользовательские загрузчики классов (обычно по одному на тестовый класс) для создания модифицированных версий из насмешливых классов. Такое интенсивное использование пользовательских загрузчиков классов может привести к конфликты с сторонними библиотеками, следовательно, необходимо иногда использовать @PowerMockIgnore ( "package.to.be.ignored" ) аннотация по тестовым классам.
• Механизм, используемый JMockit (аппаратура исполнения через "Java-агент" ) проще и безопаснее, хотя это требует прохождения параметр -javaagent для JVM, когда разработка на JDK 1.5; на JDK 1.6+ (который всегда можно использовать для разработки, даже если развертывание на более старой версии) нет такого требование, поскольку JMockit может прозрачно загружать Java-агент с использованием API-интерфейса Attach.

Еще один недавний издевательский инструмент Mockito. Хотя он не пытается для преодоления ограничений инструменты (jMock, EasyMock), он делает ввести новый стиль поведения тестирование с помощью mocks. JMockit также поддерживает этот альтернативный стиль, через API проверок.

JMockit vs Mockito

• Mockito полагается на явные вызовы для своего API, чтобы отделить код между записью (когда (...)) и проверьте (проверьте (...)) фазы. Эта означает, что любое обращение к макету объект в тестовом коде также потребует призыв к насмешливому API. Кроме того, это часто приводит к повторяющиеся, когда (...) и проверить (mock)... звонки.
• С JMockit подобных вызовов не существует. Конечно, у нас есть новые NonStrictExpectations() и новые Вызов конструктора Verifications(), но они встречаются только один раз за испытание (обычно) и полностью отдельно от призывов к издевавшихся методов и конструкторов.
• API Mockito содержит несколько несоответствий в синтаксисе, используемом для призывы к издевательствам. в этап записи, у нас есть призывы, подобные когда (mock.mockedMethod(args))... while в фазе проверки этот же вызов будут записаны как проверить (макет).mockedMethod(арг). Обратите внимание, что в первом случае сделано обращение к mockedMethod прямо на макет объекта, в то время как в второй случай сделан на объект, возвращаемый проверкой (mock).
• JMockit не имеет таких несоответствий, потому что призывы к издевательские методы всегда делаются прямо на издевательствах самих себя. (Только за одним исключением: сопоставлять вызовы на одном и том же посмеянный экземпляр, onInstance (mock) вызова, что приводит к onInstance (макет).mockedMethod(арг); большинству тестов не потребуется использовать это, хотя.)
• Как и другие издевательские инструменты, которые полагаются на метод цепочка/упаковка, Mockito также работает в несогласованный синтаксис при обрушении недействительными методами. Например, вы пишете когда (mockedList.get(1)). thenThrow (новый RuntimeException()); за непустую метод и doThrow (новый RuntimeException()), когда (mockedList).clear(). для пустоты. С JMockit это всегда один и тот же синтаксис: mockedList.clear(); result = new RuntimeException();.
• Еще одна непоследовательность возникает при использовании шпионов Mockito: "издевается", которые позволяют реальным методам быть выполненный на экземпляре spied. Для Например, если шпион ссылается на пустой Список, затем вместо написания когда (spy.get(0)). thenReturn ( "foo" ) вы нужно будет написать doReturn ( "Foo" ). когда (шпион).get(0). С JMockit - динамическая функция обеспечивает аналогичную функциональность шпионов, но без этого реальные методы выполняются только во время этап воспроизведения.
• В EasyMock и jMock, первом издевательском API для Java, основное внимание было уделено полностью на записи ожидаемых призывы насмешливых методов, для макет объектов, которые (по умолчанию) не разрешить неожиданные вызовы. Те API также обеспечивают запись разрешенные вызовы для макетов объектов которые допускают неожиданные вызовы, но это рассматривалось как второй класс особенность. Кроме того, с этими инструментов нет никакого способа явно проверять вызовы для издевок после проверяется код. Все такие проверки выполняются неявно и автоматически.
• В Mockito (а также в Unitils Mock) противоположная точка зрения приняты. Все вызовы для издевательства объектов что может произойти во время теста, независимо от того, записаны они или нет, разрешены, никогда не ожидал. Проверка выполняется явно после кода испытание проводится, никогда автоматически.
• Оба подхода слишком экстремальны и, следовательно, менее оптимальны. Ожидания и проверки JMockit является единственным API, который позволяет разработчик, чтобы лучшее сочетание строгих (ожидаемых по умолчанию) и нестрогий (разрешенный default) mock invocations для каждого тест.
• Чтобы быть более понятным, API Mockito имеет следующий недостаток. если ты необходимо проверить, что вызов непустой издевавшийся метод произошел во время теста, но для испытания требуется вернуть значение из этого метода, который отличается от значения по умолчанию для возвращаемый тип, то тест Mockito будет иметь повторяющийся код: a когда (mock.someMethod()). thenReturn (хуг) вызовите фазу записи и проверьте (mock).someMethod() в проверьте фазу. С JMockit строгий ожидание всегда можно записать, которые не должны быть явно проверено. Альтернативно, вызов ограничение count (times = 1) может быть для любых зарегистрированных нестрогих ожидание (с Mockito такой ограничения могут быть указаны только в проверить (mock, constraint)).
• Mockito имеет плохой синтаксис для проверок по порядку и для полного проверки (то есть проверки все вызовы для издевательства объектов явно проверяется). Во-первых случае, дополнительный объект должен быть и вызовы для проверки, сделанные на it: InOrder inOrder = inOrder (mock1, mock2,...). Во втором случае звонки например checkNoMoreInteractions (mock) или verifyZeroInteractions (mock1, mock2) необходимо сделать.
• С JMockit вы просто пишете новый VerificationsInOrder() или новый FullVerifications() вместо новых Проверки() (или новые FullVerificationsInOrder() для объединения оба требования). Нет необходимости указывать к которым относятся макеты объектов. нет дополнительные шутки API-вызовов. И как бонус, вызывая unverifiedInvocations() внутри упорядоченный блок проверки, вы можете выполнять проверки порядка которые просто невозможны в Мокито.

Наконец, Инструментарий тестирования JMockit имеет более широкий охват и более амбициозную цели, чем другие издевательские инструменты, в чтобы обеспечить полную и сложное тестирование разработчиков решение. Хороший API для насмешек, даже без искусственных ограничений, не достаточно для продуктивного создания тесты. IDE-агностик, простой в использовании, и хорошо интегрированный инструмент покрытия кода также важно, и что Цель JMockit - предоставить. Еще одна часть тестирования разработчика набор инструментов, который станет более полезным поскольку набор тестов растет по размеру, способность к постепенному повторному тестированию после локализованного изменения производства код; это также включено в Инструмент покрытия.

(предоставлено, источник может быть предвзятым, но хорошо...)

Я бы сказал, перейдите с JMockit. Это самый простой в использовании, гибкий и работает практически во всех случаях даже с трудными и сценариями, когда вы не можете контролировать тестируемый класс (или вы не можете его сломать из-за причин совместимости и т.д.).

Мой опыт работы с JMockit был очень положительным.

Ответ 2

Я работал с Mockito и JMockit, и мой опыт с ними:

• Mockito:

  • неявное смехотворное (- > лучшее удобство использования, но имеет опасность неспособности обнаружить недопустимые вызовы метода для mocks)
  • явная проверка

• EasyMock:

  • explict mocking
  • неявная проверка

• JMockit:

  • поддерживает как

• Кроме того, другие преимущества JMockit:

  • Если вы издеваетесь над статическими методами/конструкторами и т.д. (например, расширяя старую устаревшую базу кода без UT), у вас будет два варианта: 1) Mockito/EasyMock с расширением Powermock или 2) Jmockit
  • отчет о встроенном покрытии

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

Ответ 3

Я использую jMockit только из-за его библиотек отражения в Deencapsultation.class. Я действительно люблю стиль Mockito, но я отказываюсь менять свой код и испортить свой API, чтобы ограничить рамки тестирования. И я поклонник тестирования всего моего кода, поэтому ядро, которое не может легко тестировать частные методы, не является тем, что я хочу использовать.

Меня поколебала в этой статье

После (по общему признанию, большой) кривой обучения jMockit теперь является моим основным модулем тестирования модулей для mocks.

Ответ 4

Для простого тестирования нашей устаревшей кодовой базы (с множеством вызовов статических методов и т.д.) JMockit был бесценен. [Бесстыдный плагин для статьи в моем блоге]

Ответ 5

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