Mga sikat na anotasyon sa JUnit

7.1 @Suite annotation

At ilang mas madalas na ginagamit na anotasyon. Kahit na hindi mo ginagamit ang mga ito, tiyak na makikita mo ang mga pagsubok sa kanila. Samakatuwid, ito ay kinakailangan upang maunawaan ang hindi bababa sa mga pangkalahatang termino kung ano ang nakasulat doon.

Ang mga pagsusulit ay maaaring pagsamahin sa mga pangkat. Mayroong espesyal na anotasyon para dito @Suite. Halimbawa:

@Suite
@SuiteDisplayName("JUnit Platform Suite Demo")
@SelectPackages("com.codegym.test")
@IncludeClassNamePatterns(".*Tests")
class SuiteDemo {
}

Sa kasong ito, ang @Suite annotation ay ipinares sa iba pang anotasyon.

• SuiteDisplayName– itinatakda ang pangalan ng pangkat ng pagsubok sa log;
• SelectPackages- nagtatakda ng listahan ng mga pakete kung saan hahanapin ang mga klase ng pagsubok;
• IncludeClassNamePatterns– nagtatakda ng pattern ng mga pangalan ng klase ng pagsubok.

Bakit ganito ang kahirapan? Well isipin na ang lahat ng mga pagsubok ng proyekto ay naisakatuparan, sabihin natin, 50 oras. At ang pag-execute sa kanila pagkatapos ng bawat commit ay napakamahal. Sa ganoong sitwasyon, kapaki-pakinabang na lumikha ng ilang hiwalay na mga script ng pagsubok at mag-set up ng pagsubok sa isang mas nababaluktot na paraan.

7.2 @Order annotation

Ang isa pang karaniwang anotasyon ay @TestMethodOrder. Pinapayagan ka nitong tukuyin ang pagkakasunud-sunod kung saan tinatawag ang mga pamamaraan ng pagsubok sa klase ng pagsubok. Maaari itong maging lubhang kapaki-pakinabang kapag alam mong nakakaapekto ang mga tawag sa pamamaraan sa isa't isa, ngunit sa isang tiyak na pagkakasunud-sunod, dapat gumana ang lahat ayon sa nararapat. Madalas na ginagamit.

Una, maaari mong itakda ang mga pamamaraan na tatawagin sa pagkakasunud-sunod ng alpabeto :

@TestMethodOrder(MethodOrderer.MethodName.class)
public class AlphanumericOrderUnitTest {

}

Pangalawa, ang bawat paraan ay maaaring magkaroon ng isang espesyal na anotasyon kasama ang ordinal na numero nito.

@TestMethodOrder(OrderAnnotation.class)
public class OrderAnnotationUnitTest {

    @Test
    @Order(1)
    public void firstTest() {
    }

    @Test
    @Order(2)
    public void secondTest() {
    }
}

O kahit na lumikha ng isang hiwalay na klase na tutukuyin ang pagkakasunud-sunod kung saan tinawag ang mga pagsubok:

@TestMethodOrder(CustomOrder.class)
public class CustomOrderUnitTest {

}

//sort method names alphabetically, but ignoring case
public class CustomOrder implements MethodOrderer {
    public void orderMethods(MethodOrdererContext context) {
        context.getMethodDescriptors().sort(
        (MethodDescriptor m1, MethodDescriptor m2)->
           m1.getMethod().getName().compareToIgnoreCase(m2.getMethod().getName()));
    }
}

7.3 @DisplayName annotation

Sa wakas, ang bawat pagsubok ay maaaring bigyan ng pangalan. Maaari itong maging maginhawa kung maraming pagsubok at gagawa ka ng mga espesyal na senaryo (subset) ng mga pagsubok. Mayroong espesyal na anotasyon para dito @DisplayName.

Halimbawa:

@DisplayName("Friendly name for the test")
public class DisplayNameCustomTest {

    @Test
    @DisplayName("Input Validation")
    void inputData() {
    }

    @DisplayName("Checking critical situations")
    @Test
    void criticalCases() {
    }
}

Tulad ng sa kaso ng pagtatakda ng pagkakasunud-sunod ng mga pagsubok, dito maaari kang lumikha ng isang espesyal na paraan na bubuo ng mga pangalan ng mga pagsubok at mga pamamaraan ng pagsubok. Halimbawa:

@DisplayNameGeneration(DisplayNameGeneratorUnitTest.ReplaceCamelCase.class)
class DisplayNameGeneratorUnitTest {

    @Test
    void camelCaseName() {
    }

    static class ReplaceCamelCase extends DisplayNameGenerator.Standard {
        @Override
        public String generateDisplayNameForClass(Class testClass) {
            return super.generateDisplayNameForClass(testClass).toUpperCase();
        }
 }
}

Tingnan kung gaano kadali ito :)