Mockito Strict Stubbing и The Необходимо StubbingException

1. Общ преглед

В този бърз урок ще научите за Mockito UnnecessaryStubbingException . Това изключение е едно от често срещаните изключения, които вероятно ще срещнем при неправилно използване на заглушки.

Ще започнем, като обясним философията, която стои зад стриктното заглушаване и защо Mockito насърчава използването му по подразбиране. След това ще разгледаме какво точно означава това изключение и при какви обстоятелства може да възникне. В заключение ще видим пример за това как можем да потиснем това изключение в нашите тестове.

За да научите повече за тестването с Mockito, разгледайте изчерпателната ни серия Mockito.

2. Строго стърчане

С версия 1.x на Mockito беше възможно да конфигурирате и взаимодействате с макети без никакви ограничения. Това означаваше, че с течение на времето тестовете често стават прекалено сложни и понякога по-трудни за отстраняване на грешки.

От версия 2. +, Mockito въвежда нови функции, които тласкат рамката към „строгост“. Основните цели зад това са:

  • Открийте неизползваните мъничета в тестовия код
  • Намалете дублирането на тестовия код и ненужния тестов код
  • Популяризирайте по-чисти тестове, като премахвате „мъртъв“ код
  • Помогнете за подобряване на отстраняването на грешки и производителността

Спазването на тези принципи ни помага да създаваме по-чисти тестове, като премахваме ненужния тестов код . Те също така помагат да се избегнат грешки при копиране и поставяне, както и други пропуски за разработчици.

За да обобщим, стриктното набиване отчита ненужни мънички, открива несъответствие на аргументите и прави нашите тестове по-СУХИ (Не се повтаряйте) Това улеснява чистата и поддържаема кодова база.

2.1. Конфигуриране на строги заглушки

Тъй като Mockito 2. +, по подразбиране се използва строго набиване, когато инициализираме нашите макети, използвайки някое от:

  • MockitoJUnitRunner
  • MockitoJUnit.rule ()

Mockito силно препоръчва използването на някое от горните . Съществува обаче и друг начин да се даде възможност за стриктно блокиране в нашите тестове, когато не използваме правилото или бегача на Mockito:

Mockito.mockitoSession() .initMocks(this) .strictness(Strictness.STRICT_STUBS) .startMocking(); 

Един последен важен момент, който трябва да се отбележи, е, че в Mockito 3.0 всички уплътнения ще бъдат „строги“ и ще бъдат валидирани по подразбиране.

3. Пример за излишно ненужно излъчване

Най-просто казано, ненужният мъниче е извикване на метод, който никога не е бил реализиран по време на изпълнението на теста.

Нека да разгледаме един прост пример:

@Test public void givenUnusedStub_whenInvokingGetThenThrowUnnecessaryStubbingException() { when(mockList.add("one")).thenReturn(true); // this won't get called when(mockList.get(anyInt())).thenReturn("hello"); assertEquals("List should contain hello", "hello", mockList.get(1)); }

Когато стартирате тази единица тест, Mockito ще открие неизползван все още мъниче и се хвърли UnnecessaryStubbingException :

org.mockito.exceptions.misusing.UnnecessaryStubbingException: Unnecessary stubbings detected. Clean & maintainable test code requires zero unnecessary code. Following stubbings are unnecessary (click to navigate to relevant line of code): 1. -> at com.baeldung.mockito.misusing.MockitoUnecessaryStubUnitTest.givenUnusedStub_whenInvokingGetThenThrowUnnecessaryStubbingException(MockitoUnecessaryStubUnitTest.java:37) Please remove unnecessary stubbings or use 'lenient' strictness. More info: javadoc for UnnecessaryStubbingException class.

За щастие от съобщението за грешка става съвсем ясно какъв е проблемът тук. Също така можем да видим, че съобщението за изключение дори ни насочва към точния ред, който причинява грешката.

Защо се случва това? Е, първото, когато извикването конфигурира нашия макет да върне вярно, когато извикаме метода на добавяне с аргумента „един“ . След това обаче не извикваме този метод по време на останалата част от изпълнението на модулния тест.

Mockito ни казва, че първата ни линия, когато е излишна и може би сме допуснали грешка при конфигурирането на нашите заглушки.

Въпреки че този пример е тривиален, лесно е да си представите, когато се подигравате със сложна йерархия от обекти, как този вид съобщение може да подпомогне отстраняването на грешки и да бъде иначе много полезно.

4. Заобикаляне на стриктното забиване

И накрая, нека видим как да заобиколим строгите мъничета. Това е известно и като снизходително зашеметяване.

Понякога трябва да конфигурираме конкретни поглъщания, за да бъдат по-снизходителни, като същевременно поддържаме всички останали поглъщания и подигравки, за да използваме стриктно поглъщане:

@Test public void givenLenientdStub_whenInvokingGetThenThrowUnnecessaryStubbingException() { lenient().when(mockList.add("one")).thenReturn(true); when(mockList.get(anyInt())).thenReturn("hello"); assertEquals("List should contain hello", "hello", mockList.get(1)); }

В горния пример използваме статичния метод Mockito.lenient (), за да активираме снизходителното забиване на метода за добавяне на нашия макет списък.

Снизходителните мънички заобикалят правилата за валидиране на „строгите стърчащи“. Например, когато забиването е декларирано като снизходително, то няма да бъде проверено за потенциални проблеми със забиване, като ненужното забиване, описано по-рано.

5. Заключение

В тази кратка статия започнахме с въвеждането на концепцията за строго забиване в Mockito и разбрахме философията, поради която е въведена и защо е важна.

След това разгледахме пример за Un Необходимото излъчване на изключение, преди да завършим с пример за това как да активираме снизходителното забиване в нашите тестове.

Както винаги, пълният изходен код на статията е достъпен в GitHub.