JUnit Анотация за тестови случаи @Before @BeforeClass

⚡ Умно обобщение

JUnit е най-широко използваната рамка за модулно тестване за Java, а анотациите на тестовите приспособления контролират точно какво се случва преди и след изпълнението на всеки тестов метод в тестов клас.

  • 🔘 за фиксиране: Тестовата приспособляемост е фиксираният контекст на обекти и ресурси, в които се изпълнява тестовият случай.
  • ☑️ Setup: @Before се изпълнява преди всеки тестов метод, докато @BeforeClass се изпълнява веднъж преди целия клас.
  • ✅ Разглобяване: @After се изпълнява след всеки тест, дори когато тестът хвърля резултат или твърдението е неуспешно.
  • 🧪 Поръчка: Първо се изпълнява суперкласът @Before, след това подкласът @Before, @Test и накрая всеки @After.
  • 🛠️ Runner: JUnitCore.runClasses() изпълнява тестови класове и връща обект Result, съдържащ всеки неуспех.
  • 📊 JUnit 5: @Before, @After, @BeforeClass и @AfterClass стават @BeforeEach, @AfterEach, @BeforeAll и @AfterAll.

JUnit тестова приставка с анотации @Before и @BeforeClass

JUnit е най-популярната единица Тестване рамка в Java. Изрично се препоръчва за Единично тестване. JUnit не изисква сървър за тестване на уеб приложение, което прави процеса на тестване бърз.

- JUnit Framework също позволява бързо и лесно генериране на тестови случаи и тестови данни. The org.junit пакетът се състои от много интерфейси и класове за JUnit тестване, като например Test, Assert, After и Before. По-широкият JUnit семейството гради върху същите тези градивни елементи.

Какво е тестово приспособление?

Преди да разберем какво е тестова приставка, нека разгледаме кода по-долу.

Този код е предназначен да изпълни два тестови случая върху прост файл.

public class OutputFileTest {
    private File output; 
    output = new File(...);
    output.delete(); 
public void testFile1(){
        //Code to verify Test Case 1
}
    output.delete();
    output = new File(...);
public void testFile2(){
        //Code to verify Test Case 2
}
 output.delete(); 
}

Малко проблеми тук

  • Кодът не е четлив.
  • Кодът не е лесен за поддръжка.
  • Когато тестовият пакет е сложен, кодът може да съдържа логически проблеми.

Сравнете същия код, като използвате JUnit.

public class OutputFileTest		
{
    private File output; 
    @Before public void createOutputFile() 
    { 
       output = new File(...);
    }
  
	@After public void deleteOutputFile() 
    {
        output.delete(); 
    } 
     
    @Test public void testFile1() 
    {
       // code for test case objective
    } 
	@Test public void testFile2() 
    {
       // code for test case objective
    }
}

Кодът е много по-четим и лесен за поддръжка. Горната структура на кода е тестово приспособление.

Тестът е контекст, в който a JUnit Тестов случай бяга. Обикновено тестовите устройства включват:

  • Обекти или ресурси, които са налични за всеки тестов случай.
  • Необходими дейности, които правят тези обекти и ресурси достъпни.
  • Тези дейности са
    1. разпределение (структура)
    2. де-разпределение (демонтиране).

Настройка и премахване

Мачовете са важни, защото JUnit пуска тези куки около всеки тест.

  • Обикновено има някои повтарящи се задачи, които трябва да бъдат изпълнени преди всеки тестов случай. Пример: създайте връзка с база данни.
  • По същия начин в края на всеки тестов случай може да има някои повтарящи се задачи. Пример: за почистване, след като изпълнението на теста приключи.
  • JUnit предоставя анотации, които помагат при настройката и демонтажа. Това гарантира, че ресурсите са освободени и тестовата система е в готовност за следващия тестов случай.

тези JUnit Анотациите са обсъдени по-долу.

Структура

@Преди анотация в JUnit се използва върху метод, съдържащ Java код, който да се изпълнява преди всеки тестов случай, т.е. той се изпълнява преди всяко изпълнение на тест.

Събаряне (независимо от присъдата)

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

Забележка:

  • Разрешено е да има произволен брой анотации, изброени по-горе.
  • Всички методи, коментирани с @Преди in JUnit ще се изпълняват преди всеки тестов случай, но могат да се изпълняват в произволен ред.
  • Можете да наследите методите @Before и @After от суперклас. Изпълнението е както следва и е стандартен процес на изпълнение в JUnit.
  1. Изпълнете JUnit @Before методи в суперкласа
  2. Изпълнете методите @Before в този клас
  3. Изпълнете метод @Test в този клас
  4. Изпълнете методите @After в този клас
  5. Изпълнете методите @After в суперкласа

JUnit Бележка от 5 г.: тези анотации са JUnit 4 (org.junit). JUnit 5 ги преименуваха на org.junit.jupiter.apiи JUnit 4 кода по-долу все още работи под винтидж енджина.

JUnit 4 анотация JUnit 5 (Юпитер) еквивалент Писти
@Преди @BeforeEach Преди всеки метод на изпитване
@След @AfterEach След всеки метод на изпитване
@BeforeClass @ПредиВсички Веднъж пред целия клас
@След часовете @AfterAll Веднъж след целия клас
@Игнориране @Инвалид Пропуска анотирания тест

Пример: Създаване на клас с файл като тестова приспособление

public class OutputFileTest		
{
    private File output; 
    @Before	public void createOutputFile() 
    { 
       output = new File(...);
    }
  
	@After public void deleteOutputFile() 
    {
        output.delete(); 
    } 
     
    @Test public void testFile1() 
    {
       // code for test case objective
    } 
	@Test public void testFile2() 
    {
       // code for test case objective
    }
}

В горния пример веригата на изпълнение ще бъде следната. Диаграмата tracедин цикъл създаване-тест-изтриване на метод за тестване.

JUnit @Before и @After изпълнението се извършва чрез верига около два тестови метода

  1. createOutputFile()
  2. testFile1()
  3. deleteOutputFile()
  4. createOutputFile()
  5. testFile2()
  6. deleteOutputFile()

Предположение:

testFile1() се изпълнява преди testFile2(), което не е гарантирано.

Еднократна настройка

  • Възможно е да се изпълни метод само веднъж за целия тестов клас, преди да се изпълни някой от тестовете и преди всеки @Преди метод(и).
  • „Еднократната настройка“ е полезна за стартиране на сървъри, отваряне на комуникации и подобна работа. Затварянето и повторното отваряне на ресурси за всеки тест отнема време.
  • Това може да стане с помощта на анотацията @BeforeClass in JUnit.
@BeforeClass public static void Method_Name() {	
    // class setup code here	
 }	

Методът трябва да бъде публична статична празнота, Защото JUnit извиква го преди да съществува какъвто и да е тестов екземпляр.

Събаряне само веднъж

  • Подобно на еднократната настройка, наличен е и метод за еднократно почистване. Той се изпълнява след всички методи за тестови случаи и @След анотациите са изпълнени.
  • Полезно е за спиранеping сървъри и затваряне на комуникационните връзки.
  • Това може да стане с помощта на @След часовете анотация.
 @AfterClass public static void Method_Name()	
 {	
    // class cleanup code here	
 }	

JUnit Тестови пакети

С поставените устройства, свързаните тестови класове обикновено се групират и стартират заедно.

Ако искаме да изпълним множество тестове в определен ред, това може да стане чрез комбиниране на всички тестове на едно място. Това място се нарича набор от тестове. Повече подробности за това как да се изпълняват набори от тестове и как се използват в JUnit са обхванати от това настойнически.

JUnit Тест бегач

JUnit предоставя инструмент за изпълнение на вашите тестови случаи.

  • JUnitЯдро клас се използва за изпълнение на тези тестове.
  • Метод, наречен runClasses предоставена от org.junit.runner.JUnitЯдро се използва за изпълнение на един или няколко тестови класа.
  • Типът връщане на този метод е Резултат обект (org.junit.runner.Result), който се използва за достъп до информация за тестовете. Вижте следния примерен код за повече яснота.
public class Test {				
			public static void main(String[] args) {									
       		Result result = JUnitCore.runClasses(CreateAndSetName.class);					
			for (Failure failure : result.getFailures()) {							
         		System.out.println(failure.toString());					
      }		
      System.out.println(result.wasSuccessful());					
   }		
}      

В горния код обектът „резултат“ се обработва, за да се получат неуспешните и успешните резултати от тестовите случаи, които изпълняваме. Помощни елементи като assertEquals повдигнете тези неуспехи, докато @Игнориране пропуска тест.

JUnit Бележка от 5 г.: JUnitЯдро е JUnit 4 бегач. JUnit 5 го замества с JUnit платформа Launcher API, обикновено стартиран от IDE, Gradle или Maven Surefire.

Първо JUnit Програма

Добри познания за SDLC, Java програмирането и основите на тестване на софтуер процесът помага за разбирането на JUnit програма, както и знанието как единични тестове различават се от интеграционните тестове.

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

MyFirstClassTest.java

package guru99.JUnit;		

import static org.junit.Assert.*;				

import org.junit.Test;		

public class MyFirstClassTest {				

    @Test		
    public void myFirstMethod(){					
        String str= "JUnit is working fine";					
        assertEquals("JUnit is working fine",str);					
    }
}		

TestRunner.java

За да изпълним нашия тестов метод (по-горе), трябва да създадем тестов бегач. В тестовия бегач трябва да добавим класа test като параметър в JUnitМетодът runClasses() на Core. Той ще върне резултата от теста, въз основа на това дали тестът е преминал успешно или неуспешно.

За повече подробности по този въпрос вижте кода по-долу:

package guru99.JUnit;		

import org.junit.runner.JUnitCore;		
import org.junit.runner.Result;		
import org.junit.runner.notification.Failure;		

public class TestRunner {				
			public static void main(String[] args) {									
            Result result = JUnitCore.runClasses(MyFirstClassTest.class);					
			for (Failure failure : result.getFailures()) {							
              System.out.println(failure.toString());					
      }		
      System.out.println("Result=="+result.wasSuccessful());							
   }		
}      	

Продукция

Веднъж TestRunner.java изпълнява нашите тестови методи, получаваме резултат като неуспешен или успешен. Моля, вижте обяснението на резултата по-долу:

  1. В този пример, след изпълнение MyFirstClassTest.java, тестът е преминал успешно и резултатът е в зелено.
  2. Ако се беше провалило, резултатът щеше да се покаже в червено, а повредата може да се наблюдава в грешката. tracд. Вижте JUnit Графичен потребителски интерфейс по-долу:

Eclipse JUnit изглед, показващ зелена лента за преминаване на теста MyFirstClassTest

Въпроси и Отговори

JUnit създава нов екземпляр на тестовия клас за всеки тестов метод, така че не съществува екземпляр, когато трябва да се изпълни код на ниво клас. Декларирането на метода static позволява JUnit извикайте го директно.

Не. Редът на методите е умишлено неопределен. JUnit 4 оферти @FixMethodOrder и JUnit 5 предлага @TestMethodOrder, но в зависимост от сигналите за поръчка, свързани тестове.

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

Новите проекти трябва да добавят JUnit 5 агрегатен артефакт org.junit.jupiter:junit-jupiter. Екипи, притежаващи наследство JUnit 4 пакета добавят junit-vintage-engine, така че и двата да работят на една платформа.

Фиксираната конфигурация (fixture) е целият подготвен контекст около теста, включително реални файлове или връзки. Мокетната конфигурация (mock) е един заместител със скриптово поведение, често създаден от самата конфигурация.

Да, чрез @BeforeClass в JUnit 4 или @BeforeAll в JUnit 5. Споделените устройства са по-бързи, но имат изтичащо състояние, така че ги резервирайте за скъпи ресурси само за четене.

Асистентите с изкуствен интелект прочитат даден клас, правят извод за сътрудниците, от които се нуждае, и изготвят @Before настройката със съответстващо @After почистване. Винаги преглеждайте генерираните твърдения сами.

Копилот на GitHub изгражда тестов клас от сигнатура на метод, включително анотации на жизнения цикъл. Често по подразбиране е JUnit 4 импорта, така че проверете дали пакетът съответства на вашия двигател.

Обобщете тази публикация с: