Գնահատել նախագիծը
← Բոլոր հրապարակումները

Kotest. Kotlin-ի թեստավորման ֆրեյմվորք, որին կսիրահարվեք

Kotest-ը Kotlin-ով գրված հարուստ հնարավորություններով, հարմար և մոդուլային թեստավորման ֆրեյմվորք է։ Ծանոթացեք, թե ինչ կարող է այն անել։

22 րոպե
ֆրեյմվորքներKotlinKotlinServerSide

Kotest-ը Kotlin-ով գրված հարուստ հնարավորություններով, հարմար և մոդուլային թեստավորման ֆրեյմվորք է։

Այս հոդվածում ես շատ ավելի ուշադիր կանդրադառնամ այն բանին, թե ինչ կարող է անել Kotest-ը։ Սպասեք բազմաթիվ գործնական օրինակների և կոդի հատվածների, ուստի պատրաստվեք։

Kotest-ի մոդուլները

Kotest-ը կառուցված է մոդուլներից, և այս պահին այն ունի երեք հիմնական մոդուլ՝ Test Framework, Assertions Library և Property Testing։ Կարող եք օգտագործել դրանք բոլորը միասին, բայց նույնքան հեշտությամբ կարող եք ընտրել միայն անհրաժեշտները և համադրել դրանք թեստավորման այլ ֆրեյմվորքների կամ գրադարանների հետ։

Օրինակ՝ կարող եք օգտագործել միայն Kotest Assertions-ը ձեր JUnit թեստերի ներսում։ Կամ կարող եք թեստեր գրել Kotest-ի հիմնական Test Framework-ով և assertion-ների համար հենվել AssertJ-ի վրա։ Կարող եք նաև Kotest-ը համադրել Spring Boot Tests-ի հետ, և դա նույնպես սահուն է աշխատում։

Kotest Test Framework

Test Framework-ը Kotest-ի կենտրոնական մոդուլն է։ Kotest-ի թեստերը ճկուն են և կարող են աշխատել JVM, Javascript և Native միջավայրերում, ինչը այն դարձնում է բազմապլատֆորմ թեստավորման ֆրեյմվորք։ Այս գրառման մեջ, սակայն, ես կկենտրոնանամ բացառապես JVM-ի վրա։

Այն Gradle նախագծին ավելացնելու համար բավական է հայտարարել ստորև բերված կախվածությունը և Gradle-ին ասել, որ թեստերը աշխատեցնի JUnit պլատֆորմի վրա.

dependencies {
   …
   testImplementation("io.kotest:kotest-runner-junit5:$kotestVersion")
   …
}

tasks.test {
   useJUnitPlatform()
}

Թեստավորման ոճերը

Եթե ստիպված լինեի ընտրել մեկ բառ, որը լավագույնս բնութագրում է Kotest ֆրեյմվորքը, դա անշուշտ կլիներ ճկունություն։ Դա մեծ մասամբ պայմանավորված է նրանով, թե ինչպես է Kotest-ը թույլ տալիս գրել թեստային դեպքեր։ Այն տալիս է ոչ պակաս, քան տասը տարբեր թեստավորման ոճ։
Արդյունքում, Kotest-ին անցնող ցանկացած մշակող պետք է իրեն հարմար զգա՝ անկախ այն տեխնոլոգիայից, որից եկել է, քանի որ թեստավորման յուրաքանչյուր ոճ հիմնվում է գոյություն ունեցող ծրագրավորման լեզվի կամ թեստավորման ֆրեյմվորքի վրա։

Օրինակ՝ այսպես է թեստային դեպքը տեսք ունի լռելյայն թեստավորման ոճով, որը կոչվում է FunSpec.

class MyFunSpec: FunSpec({
   test("2 plus 2 should be 4") {
       (2 + 2) shouldBe 4
   }
})

Եթե BDD-ն ավելի շատ ձեր սրտով է, նույն թեստային դեպքը կարող եք գրել այլ կերպ՝ BehaviorSpec-ով.

class MyBehaviorSpec: BehaviorSpec({
   Given("Number 2") {
       val num1 = 2
       And("another number 2") {
           val num2 = 2
           When ("adding those numbers") {
               val result = num1 + num2
               Then("the result should be 4") {
                   result shouldBe 4
               }
           }
       }
   }
})

Սա առաջարկվող տասը ոճից ընդամենը երկուսն է։ Բոլորին ծանոթանալու համար ազատ զգացեք դիտել Kotest-ի պաշտոնական փաստաթղթերը, որոնք նկարագրում են յուրաքանչյուր թեստավորման ոճ։

Kotest և JUnit

Կա ևս մի բան, որ կցանկանայի նշել։ Ուշադիր նայեք, թե ինչպես է Kotest-ը սահմանում թեստային դեպքերը։ JUnit-ում թեստային դեպքերը ֆունկցիաների սահմանումներ են, մինչդեռ Kotest-ում դրանք ֆունկցիաների կանչեր են, որոնք տեղադրված են Spec դասի init բլոկում։ Ըստ էության, Kotest-ը մեզ տալիս է DSL թեստեր գրելու համար։ Այս թվացյալ փոքր մանրամասնությունը բացում է հզոր հնարավորություն՝ թեստային դեպքերի դինամիկ գեներացում runtime-ում։

Օրինակ՝ կարող ենք գրել մի բան այսպիսին.

class DynamicSpec : FunSpec({
   for (i in 1..10) {
       test("Test nr $i") {
           i shouldBeGreaterThan 0
       }
   }
})

Վերը բերված օրինակը ստեղծում է 10 թեստային դեպք, որոնցից յուրաքանչյուրի անունը կառուցվում է դինամիկ կերպով։ Այս կոնկրետ օրինակը կարող է շատ գործնական չլինել, բայց լավ է ցուցադրում գաղափարը։

Սակայն կարող ենք ավելի առաջ գնալ։ Պատկերացրեք, որ մեր նախագծում կա src/test/resources/test_definitions դիրեկտորիա, որը պարունակում է .txt files, որոնց բովանդակությունը դասավորված է այսպես.

This is first test
2,2
4

Այդ դեպքում կարող ենք գրել թեստերի հավաքածու, որը թեստային դեպքերը գեներացնում է այս ֆայլերից ուղղակի թռիչքի ժամանակ.

class DynamicSpec : FunSpec({
   File("src/test/resources/test_definitions").walkTopDown()
       .filter { it.name.endsWith(".txt") }
       .forEach { testFile ->
           val lines = testFile.readLines(Charsets.UTF_8)
           val testName = lines[0]
           val numbersToBeAdded = lines[1]
               .split(",")
               .map(String::toInt)
           val expectedResult = lines[2].toInt()

           // This will generate separate test case for each file in test_definitions directory
           test(testName) {
               numbersToBeAdded.reduce(Int::plus) shouldBe expectedResult
           }
       }
})

Եվ ահա, մենք կառուցեցինք դինամիկ թեստերի հավաքածու, որի թեստային դեպքերը գալիս են արտաքին տեքստային ֆայլերից՝ սեփական բովանդակությամբ։

Սա, իհարկե, ընդամենը մեկ օրինակ է, և այս հնարավորությունն օգտագործելու շատ ստեղծագործական եղանակներ կան։ Հիանալի չէ՞։

Lifecycle Hooks և Extensions

Բացի իր տարբեր ոճերից, Kotest-ն ունի նաև lifecycle hooks-ի և extensions-ների ճկուն մեխանիզմ։ Այն ներառում է բոլոր սովորական hook-երը, որոնք ծանոթ են թեստավորման այլ ֆրեյմվորքներից, ինչպես beforeSpec, afterSpec, beforeTest, afterTest և այլն։ Դրանից բացի, մենք կարող ենք հեշտությամբ գրել և միացնել սեփական extension-ներն ու hook-երը։

Պայմանական կատարում

Kotest-ը առաջարկում է հզոր միջոցներ թեստերը պայմանով աշխատեցնելու համար։ Ունեք շատ ընտրություններ՝ սկսած որոշակի թեստային դեպքերն ուղղակի անջատելուց մինչև միայն այն դեպքերն աշխատեցնելը, որոնք բավարարում են runtime-ում ստուգվող բարդ պայմաններին։ Ստորև բերված օրինակը ցույց է տալիս, թե ինչ է հնարավոր այստեղ.

test("This will never run").config(enabled = false) {
   // test something here
}

test("This will only run on Linux").config(enabled = SystemUtils.IS_OS_LINUX) {
   // test something here
}

fun isNight() = now().isAfter(LocalTime.of(20, 0)) || now().isBefore(LocalTime.of(8, 0))

test("This will run only nightly").config(enabledIf = { isNight() }) {
   // test something here
}

Թեստերի կազմակերպում և ֆիլտրում

Kotest-ը տալիս է թեստերը կառուցվածքավորելու և ֆիլտրելու մի քանի եղանակ, ինչը օգնում է մեծ թեստային հավաքածուների հետ աշխատելիս և կոդային բազայի որոշակի մասերի վրա կենտրոնանալիս։

Թեստերը կառուցվածքավորելու կենտրոնական հնարավորությունը DescribeSpec-ի describe ֆունկցիան է, որը թույլ է տալիս առնչվող թեստերը մեկ խմբում դնել։ Սա օգնում է կազմակերպել թեստային կոդը այնպես, որ այն արտացոլի թեստավորվող ֆունկցիոնալությունը, ինչը հեշտացնում է դրա ընթերցումն ու սպասարկումը։

Ստորև բերված է թեստերի խմբավորման օրինակ describe ֆունկցիայով.

class MyDescribeSpec : DescribeSpec({
   describe("Arithmetic operations") { 
      it("should add numbers correctly") { 
         (2 + 2) shouldBe 4 
      }

      it("should subtract numbers correctly") {
         (4 - 2) shouldBe 2
      }
   }
})

Խմբավորումից բացի, Kotest-ը թույլ է տալիս նաև թեստերը պիտակավորել և ֆիլտրել tags-երով։ Tags-երը կարող եք օգտագործել թեստերը դասակարգելու համար ըստ այնպիսի բաների, ինչպիսիք են ֆունկցիոնալությունը, առաջնահերթությունը կամ միջավայրը։ Այս tags-երի հիման վրա կարող եք թեստերը ներառել կամ բացառել գործարկումից, ինչը հատկապես օգտակար է մեծ թեստային հավաքածուներով խոշոր նախագծերում։

Ահա թե ինչպես կարելի է թեստերը պիտակավորել.

class MyTaggedSpec : FunSpec({
    test("important test").config(tags = setOf(MyTags.Important)) {
        // test code
    }

    test("optional test").config(tags = setOf(MyTags.Optional)) {
        // test code
    }
})

object MyTags {
    val Important = Tag("Important") 
    val Optional = Tag("Optional")
}

Միայն կարևոր թեստերն աշխատեցնելու համար օգտագործեք այս հրամանը.

gradle test --tests * --include-tag Important

describe ֆունկցիայի և tags-երի միջոցով կարող եք արդյունավետ կազմակերպել և ֆիլտրել ձեր թեստերը, ինչը դրանք դարձնում է ավելի հեշտ կառավարելի և գործարկելի, երբ անհրաժեշտ է։

Coroutines-ի աջակցություն

Ինչպես կսպասեք Kotlin-ում և Kotlin-ի համար կառուցված ֆրեյմվորքից, Kotest-ն ունի coroutines-ի աջակցություն տուփից դուրս։ Թեստային դեպքերը կարող են աշխատել coroutineTestScope-ի ներսում, որը միացվում է կամ առանձին թեստային դեպքի config ֆունկցիայում, կամ գլոբալ՝ spec-ի բոլոր թեստային դեպքերի համար։ Այդ դեպքում թեստն աշխատում է kotlinx.coroutines գրադարանի տրամադրած TestDispatcher-ի վրա, ինչը թույլ է տալիս թեստերի ներսում վերահսկել վիրտուալ ժամանակը, բաց թողնել ուշացումները և այլն։

Kotlin coroutines-ը այնքան լայն թեմա է, որ ես այս գրառման մեջ դրանց մասին ավելի մանրամասն չեմ խոսի։ Սակայն հետևեք մեր բլոգին՝ coroutines-ի մասին հետագա հոդվածների համար, որոնք շուտով պետք է հրապարակվեն այնտեղ։

Տվյալներով ղեկավարվող թեստավորում

Դուք հավանաբար ծանոթ եք պարամետրիզացված թեստերին թեստավորման այլ ֆրեյմվորքներից (ինչպես JUnit 5-ի @ParameterizedTest-ը կամ Spock-ի where բանալի բառը)։ Kotest-ի տվյալներով ղեկավարվող թեստերը հիմնված են նույն գաղափարի վրա։ Դրա գաղափարն այն է, որ.

  • գրվում է թեստային դեպք, որը պարամետրեր է ընդունում,
  • պատրաստվում են այդ պարամետրերի մի քանի հավաքածուներ,
  • թեստային դեպքը աշխատեցվում է պարամետրերի յուրաքանչյուր հավաքածուով՝ ակնկալելով, որ ամեն անգամ այն կանցնի։

Տվյալներով ղեկավարվող թեստավորումն օգտագործելուց առաջ նախ պետք է ձեր Gradle build ֆայլին ավելացնել այս կախվածությունը.

testImplementation("io.kotest:kotest-framework-datatest:$kotestVersion")

Ահա թե ինչպես կարող եք կառուցել այդպիսի թեստային դեպքեր Kotest-ով.

context("numbers should add up to 10") {
   withData(
       Pair(5, 5),
       Pair(3, 7),
       Pair(1, 9)
   ) { (num1, num2) ->
       num1 + num2 shouldBe 10
   }
}

context("numbers should add up to given result") {
   withData(
       nameFn = { "${it.first } + ${it.second} = ${it.third}" }, // generate descriptive names for all cases
       Triple(1, 2, 3),
       Triple(10, 5, 15),
       Triple(-5, 5, 0),
   ) { (num1, num2, result) ->
       num1 + num2 shouldBe result
   }
}

Սրանով ավարտվում է Kotest-ի հիմնական մոդուլի մեր շրջագայությունը։ Այժմ տեսնենք մնացած երկու մոդուլների տրամադրած այլ հիանալի հնարավորությունները։

Assertions Library

Ցանկացած թեստի ամենակարևոր մասը նրա assertion-ներն են։ Դուք հավանաբար կզարմանաք, եթե ինչ-որ մեկը ասի, որ իր նախագծի կոդի ծածկույթը 100% է և բոլոր թեստերը միշտ անցնում են։ Սակայն այդ զարմանքը կչքվի այն պահին, երբ նա ավելացնի, որ իր թեստերից ոչ մեկը assertion-ներ չի պարունակում։

Բարեբախտաբար, Kotest-ը գալիս է բազմաթիվ տվյալների տիպերի համար assertion-ների ընդարձակ գրադարանով։ Եվ շնորհիվ Kotlin-ի ներկառուցված սինտակտիկ շաքարի, Kotest-ի assertion-ները նաև շատ արտահայտիչ, հարմար և ընթեռնելի են։

Assertions գրադարանը ձեր նախագծում օգտագործելու համար ավելացրեք համապատասխան կախվածությունը ձեր build ֆայլում.

testImplementation("io.kotest:kotest-assertions-core:$kotestVersion")

Matchers

Matchers-ը կազմում են Kotest assertions մոդուլի հիմքը։ Matcher-ին պատկերացրեք որպես ֆունկցիա, որը ստուգում է՝ արդյոք արժեքը համապատասխանում է ձեր ակնկալածին։ Kotest-ը գալիս է բազմաթիվ ներկառուցված matcher-ներով։ Ահա դրանցից մի քանիսը.

test("various matchers") {
   (2 + 2) shouldBe 4
   "text" shouldContain "x"
   "non null text" shouldNotBe null
   10 shouldBeGreaterThan 8
   15L should beInstanceOf<Number>()
   20 should beOfType<Int>()
   mapOf("key" to "value") shouldContainValue "value"
   listOf(1, 2, 3).shouldNotBeEmpty()
   "{\"someProp\":\"value\"}" shouldContainJsonKey "someProp"
   LocalDate.parse("2025-02-17") shouldBeAfter LocalDate.parse("2025-01-22")
}

Գուցե նկատեցիք, որ վերը բերված օրինակում մյուս matcher-ների շարքում օգտագործել եմ shouldContainJsonKey։ Սա հատուկ matcher է, քանի որ պատկանում է JSON matcher-ներին։ Այն կամ ցանկացած այլ JSON matcher օգտագործելու համար պետք է ձեր build ֆայլին ավելացնել ևս մեկ կախվածություն.

testImplementation("io.kotest:kotest-assertions-json:$kotestVersion")

Inspectors

Kotest-ն ունի նաև հատուկ API կոլեկցիաների տարրերը ստուգելու համար։ Inspectors կոչվող այս API-ն թույլ է տալիս համեմատել կոլեկցիայի պարունակությունը ձեզ անհրաժեշտ ցանկացած եղանակով։ Ահա inspectors-ի օգտագործման օրինակ.

test("Collection inspectors") {
   val numbers = listOf(2, 4, 6, 8, 10)

   numbers.forAll { it.shouldBeEven() }
   numbers.forNone { it.shouldBeOdd() }
   numbers.forSome { it shouldBeLessThan 5 }
   numbers.forExactly(2) { it shouldBeGreaterThan 7 }
   numbers.forAtMostOne { it shouldBeInRange 0..3 }
}

Սեփական matcher-ներ

Եթե ստանդարտ գրադարանում դեռ չկա ձեզ անհրաժեշտ matcher-ը, կարող եք գրել ձեր սեփականը։ Հիշեք, որ Kotlin-ի extension ֆունկցիաները և infix ֆունկցիաները դրա համար լիովին ձեր տրամադրության տակ են։

Պետք է միայն սահմանել ֆունկցիա (կամ մի քանիսը), որը ծառայում է որպես matcher.

fun aGreetingTo(name: String) = Matcher<String> { value ->
   MatcherResult(
       value.matches(Regex("Hello $name!")),
       { "Message '$value' should be a greeting to $name!" },
       { "Message '$value' should not be a greeting to $name!" }
   )
}

infix fun String.shouldBeAGreetingTo(name: String): String { // optional extension version of the matcher
   this shouldBe aGreetingTo(name)
   return this
}

infix fun String.shouldNotBeAGreetingTo(name: String): String { // optional negated extension version of the matcher
   this shouldNotBe aGreetingTo(name)
   return this
}

Թեստերում այս matcher-ներն այնուհետև կօգտագործվեն այսպես.

test("should message be a greeting to John") {
   "Hello John!" shouldBe aGreetingTo("John") // custom matcher
   "Hello Mary!" shouldNotBe aGreetingTo("John") // negated custom matcher
   "Hello John!" shouldBeAGreetingTo("John") // extension custom matcher
   "Goodbye John!" shouldNotBeAGreetingTo("John") // negated extension custom matcher
}

Կոմպոզիտ matcher-ներ

Kotest-ը թույլ է տալիս նաև տարբեր matcher-ներ (ներկառուցված, ինչպես նաև սեփական) համադրել կոմպոզիտ matcher-ների մեջ։ Այս կերպ մենք կարող ենք միավորել մեր պայմանները ավելի բարդ պայմանների մեջ և ստուգել, թե արդյոք բոլոր պայմանները բավարարված են, թե առնվազն մեկը։

val containAllABC = Matcher.all(
   contain("A"), contain("B"), contain("C")
)

val containAnyOfABC = Matcher.any(
   contain("A"), contain("B"), contain("C")
)

test("composed matchers") {
   "ABC" should containAllABC
   "A" should containAnyOfABC
}

Soft assertions

Kotest-ի ևս մեկ փոքր, բայց հարմար հնարավորությունը soft assertions-ի աջակցությունն է։ Լռելյայն Kotest-ը թեստային դեպքերն աշխատեցնում է fail-fast ռազմավարությամբ, այսինքն՝ թեստի կատարումը կանգ է առնում առաջին ձախողված assertion-ի վրա։ Այս փոքր հնարավորությունը, սակայն, թույլ է տալիս կատարել բոլոր assertion-ները՝ անկախ նրանից, թե դրանցից որոշները ձախողվում են։ Թեստային դեպքը, իհարկե, դեռ կձախողվի, եթե որևէ assertion ձախողվի. միակ փոփոխությունն այն է, որ բոլոր assertion-ները ստուգվում են անկախ դրանից։

test("soft assertions") {
   val text = "Some text"

   assertSoftly {
       text shouldContain "no such string"
       text shouldStartWith "S"
       text shouldHaveLength 100
   }
}

Ոչ դետերմինիստական թեստավորում

Երբ գրում ենք unit թեստեր, իդեալական դեպքում կցանկանայինք, որ թեստավորվող կոդը վարվի լիովին կանխատեսելի և աշխատի ակնթարթորեն։ Ցավոք, միշտ չէ, որ այդպես է։ Երբեմն մեզ հարկ է լինում թեստավորել ասինխրոն գործողություններ, որոնց մասին գիտենք միայն, որ դրանք պետք է ինչ-որ պահի ավարտվեն։ Ինչպե՞ս վարվել դրա հետ։ Kotest-ի ոչ դետերմինիստական թեստավորումը դա հեշտացնում է։

test("should eventually store order") {
   val order = Order("order-1", 99.99)

   someAsynchronousDb.save(order)

   eventually(10.seconds) { // verifies that something eventually happens
       someAsynchronousDb.getById(order.id) shouldBe order
   }
}

test("should keep data in cache according to TTL") {
   val cacheTTL = 20.seconds

   cache.put("entry-1", "some cached value")

   continually(cacheTTL) { // verifies that some condition is true for the given period of time
       cache["entry-1"] shouldBe "some cached value"
   }
}

Սա ամենն է, ինչ ուզում էի պատմել ձեզ Kotest Assertions Library-ի մասին։ Սակայն դեռ կա ևս մի հետաքրքիր բան, որ պետք է ցույց տամ ձեզ՝ Kotest-ի վերջին մոդուլը՝ Property Testing։

Property Testing

Unit թեստերը, որ մշակողները սովորաբար գրում են, հենվում են օրինակների վրա. դրանք թեստավորվող օբյեկտին փոխանցում են նմուշային մուտքային տվյալներ և ակնկալում որոշակի արդյունքներ։ Սա հայտնի է որպես օրինակների վրա հիմնված թեստավորում։ Այն շատ դեպքերում լավ է, բայց ունի իր թույլ կողմերը։ Օրինակ՝ մեր օրինակները հեշտությամբ կարող են բաց թողնել որոշ եզրային դեպքեր։ Ավելի բարդ կեղծ թեստային տվյալները ձեռքով սահմանելը նույնպես կարող է հոգնեցուցիչ լինել։ Բայց կոդը unit թեստավորելու միակ եղանակը սա չէ. կա մեկ այլ մոտեցում՝ հատկությունների վրա հիմնված թեստավորում (property-based testing), և Kotest-ը աջակցում է նաև դրան։

Property-based թեստավորման ժամանակ պատահական թեստային տվյալները, որոնք ընդգրկում են ինչպես եզրային, այնպես էլ տիպային դեպքերը, գեներացվում են ավտոմատ կերպով, և թեստը բազմիցս աշխատեցվում է այդ գեներացված տվյալներով որպես մուտք։

Property թեստավորումը ձեր նախագծում օգտագործելու համար ձեր Gradle build ֆայլին ավելացրեք հետևյալ կախվածությունը.

testImplementation("io.kotest:kotest-property:$kotestVersion")

Property թեստի ֆունկցիաներ

Ցույց տալու համար, թե ինչպես են Kotest-ում գրվում property թեստերը, ահա Ֆիբոնաչիի ֆունկցիայի համար մի քանի property թեստ.

class MyPropertyTestSpec: StringSpec({
   "test fibonacci for n > 1 using forAll and arbitrary generator" { // 1
       forAll(Arb.int(2..10)) { n ->
           fibonacci(n) == fibonacci(n - 1) + fibonacci(n - 2)
       }
   }

   "test fibonacci for n > 1 using checkAll" { // 2
       checkAll(100, Arb.int(2..10)) { n ->
           fibonacci(n) shouldBeEqual fibonacci(n - 1) + fibonacci(n - 2)
       }
   }

   "test fibonacci for n > 1 using forAll and exhaustive generator" { // 3
       forAll(Exhaustive.ints(2..10)) { n ->
           fibonacci(n) == fibonacci(n - 1) + fibonacci(n - 2)
       }
   }

   "test fibonacci for n < 0" { // 4
       checkAll(Arb.int(max = -1)) { n ->
           shouldThrow<IllegalArgumentException> { fibonacci(n) }
       }
   }
})

Այստեղ սահմանված են չորս առանձին թեստային դեպքեր, որոնցից յուրաքանչյուրը ցույց է տալիս Kotest-ի տարբեր կողմ։ Անցնենք դրանց մեկ առ մեկ.

  1. Սա հիմնական property-based թեստային դեպք է։ Առանցքային տարրը forAll ֆունկցիան է, որն իր մարմինը աշխատեցնում է բազմիցս (լռելյայն՝ 1000 անգամ)։ Arb.int(2..10)-ը գեներատոր է, որը ասում է Kotest-ին, թե որ արժեքները փոխանցի թեստին։ Այստեղ n-ը միշտ կլինի 2-ից 10 պատահական թիվ։ Առանց նշված գեներատորի Kotest-ը լռելյայն կգեներացներ թվեր Int.MIN_VALUE-ից մինչև Int.MAX_VALUE։ forAll-ի մասին ևս մի բան, որ արժե իմանալ. այն ընդունում է (a, …, n) -> Boolean տիպի լյամբդա, և թեստը անցնելու համար լյամբդայի յուրաքանչյուր կանչ պետք է վերադարձնի true։
  2. Այս թեստային դեպքը շատ նման է նախորդին, երկու հիմնական տարբերությամբ։ Նախ՝ մենք մեր property-based թեստը սահմանում ենք checkAll ֆունկցիայով՝ forAll-ի փոխարեն։ CheckAll-ը ընդունում է (a, …, n) -> Unit տիպի լյամբդա, ուստի կարող ենք մեր պայմանները ստուգել assertion-ներով. պետք չէ boolean վերադարձնել, ինչպես forAll-ում։ Երկրորդ՝ մենք բացահայտորեն սահմանում ենք թեստի իտերացիաների քանակը, այստեղ՝ 100։ Մարմինը, իհարկե, նույնպես փոքր-ինչ տարբերվում է, քանի որ այժմ ֆունկցիայի արդյունքը ստուգում ենք assertion-ներով՝ boolean արժեքներ վերադարձնելու փոխարեն։
  3. Նայելով նախորդ երկու թեստային դեպքերին, կարող եք մտածել. «Ինչո՞ւ աշխատեցնել 1000 կամ նույնիսկ 100 իտերացիա պատահական թվերով՝ պարզապես դետերմինիստական Ֆիբոնաչիի ֆունկցիան 2-ից 10 արժեքների համար թեստավորելու համար»։ Եվ իրավացի կլինեիք. այս կոնկրետ դեպքի համար ավելի լավ տարբերակ կա, որը ցույց է տրված թիվ 3 թեստային դեպքում։ Նկատեք, որ n պարամետրի համար Arbitrary Generator-ի փոխարեն այստեղ օգտագործում ենք Exhaustive.ints(2..10)։ Արդյունքում Kotest-ը գեներացնում է տրված միջակայքի յուրաքանչյուր արժեքը և թեստային դեպքն աշխատեցնում է ճիշտ մեկ անգամ յուրաքանչյուր արժեքի համար։ Այսպիսով, 1000 կամ 100 գործարկման փոխարեն ստանում ենք 9 իտերացիա, որոնք ծածկում են 2–10 միջակայքի յուրաքանչյուր արժեք։
  4. Չորրորդ թեստային դեպքը նախորդների համեմատ շատ նոր Kotest հնարավորություններ չի ներկայացնում։ Հիմնականում այն ցույց է տալիս Ints-ի համար Arbitrary Generator-ի մեկ այլ տարբերակ (Int արժեքների կիսաբաց բազմություն՝ Int.MIN_VALUE-ից մինչև -1)։ Այն նաև ցույց է տալիս, որ բացառությունները կարելի է թեստավորել property-based թեստային դեպքում։

Գեներատորների գործողություններ

Նախորդ բաժինը ներկայացրեց մի քանի գեներատոր։ Այժմ գիտեք, որ մեր property-based թեստերի համար տվյալներ կարող են արտադրել կամ Arb, կամ Exhaustive գեներատորները։ Շուտով (սպոյլեր!) կիմանաք նաև Custom Generators-ի մասին։

Այս բաժնում, սակայն, կտեսնեք, որ նույնիսկ ներկառուցված գեներատորներն ունեն հարմար գործողություններ, որոնք թույլ են տալիս հարմարեցնել դրանք մեր կարիքներին՝ սկսած գեներատորից պարզապես հաջորդ տարրը վերցնելուց մինչև գեներատորների արտադրած արժեքների հոսքերի բարդ ֆիլտրում և մապինգ։ Ահա մի քանի օրինակ.

val someRandomString: String = Arb.string(1..10).next()
val oddNumbers: Arb<Int> = Arb.int().filter { it % 2 == 1 }
val prefixedStrings: Arb<String> = Arb.string(1..5).map { "PREFIX-$it" }
val suffixedStrings: Arb<String> = Arb.string(1..5).map { "$it-SUFFIX" }
val prefixedAndSuffixed: Arb<String> = prefixedStrings.merge(suffixedStrings)

Տիպերի հայտարարությունները այստեղ պարտադիր չեն։ Ես դրանք ավելացրել եմ միայն ցույց տալու համար, որ գեներատորների գործողությունների մեծ մասը նույնպես վերադարձնում է գեներատորներ, ուստի դրանք կարող ենք օգտագործել property թեստերում ինչպես սովորաբար, կամ դրանք հետագայում վերափոխել և փոխարկել։ next գործողությունը առանձնանում է, քանի որ, ինչպես տեսնում եք, այն գեներատորից ստանում է իրական արժեք։

Assumptions

Երբեմն մուտքային պարամետրերի ոչ բոլոր համադրություններն են իմաստ ունենում թեստային դեպքի համար։ Հենց այստեղ են օգնության գալիս assumptions-ները։ Դրանք ճիշտ գործիք են, երբ ուզում ենք բաց թողնել թեստային դեպքի որոշ իտերացիաներ ըստ դրա պարամետրերի։ Assumptions-ները կարող են արտահայտվել պայմանական արտահայտությամբ կամ նույնիսկ assertion-ներով։ Ահա մի քանի օրինակ.

"test with assumptions conditional" {
   checkAll<String, String> { a, b ->
       withAssumptions(a != b) {
           // test here
       }
   }
}

"test assume conditional" {
   checkAll<String, String> { a, b ->
       assume(a != b)
       // test here
   }
}

"test with assumptions assertions" {
   checkAll<String, String> { a, b ->
       withAssumptions({
           a shouldNotBe b
       }) {
           // test here
       }
   }
}

"test assume assertions" {
   checkAll<String, String> { a, b ->
       assume {
           a shouldNotBe b
       }
       // test here
   }
}

Սեփական գեներատորներ

Ինչպես ավելի վաղ ակնարկեցի, մեր property-based թեստերը սահմանափակված չեն նախասահմանված գեներատորներով։ Kotest-ը թույլ է տալիս գրել մեր սեփական custom գեներատորները։ Իմ կարծիքով, սա հատկապես հարմար է, երբ ուզում ենք գեներացնել մեր սեփական դասերի օրինակներ։

Կարելի է իրականացնել և՛ arbitrary, և՛ exhaustive գեներատորներ։ Ստորև բերված կոդի հատվածը ցույց է տալիս, թե ինչպես.

class Address(val city: String, val street: String, val number: Int, val zipCode: String)

val citiesGenerator = listOf("New York", "London", "Paris", "Berlin", "Hamburg").exhaustive()

val addressGenerator = arbitrary {
   Address(
       city = citiesGenerator.toArb().bind(), // cannot bind to exhaustive generator directly
       street = Arb.string(5..20).bind(),
       number = Arb.positiveInt(100).bind(),
       zipCode = Arb.stringPattern("\\d{2}-\\d{3}").bind() // can also generate strings based on regex
   )
}

Այժմ կարող ենք գեներացնել Address-ի օրինակներ այնպես, ինչպես գեներացնում ենք Int-եր կամ String-եր, և օգտագործել դրանք property-based թեստային դեպքերում։ Ոչինչ չի խանգարում մեզ նման գեներացված տվյալներն օգտագործել նաև սովորական թեստային դեպքերում։ Երբ ուզում ենք թեստային տվյալները ձեռքով չսահմանել, կարող ենք պարզապես գեներացնել դրանք։

Սա ամենն է Kotest-ի Property Testing մոդուլի մասին։ Հուսով եմ՝ այս տեղեկությունը օգտակար և հետաքրքիր էր ձեզ համար։

Լավագույն փորձը

Ստորև բերված են մի քանի լավագույն փորձ, որոնք արժե հիշել Kotest-ի հետ աշխատելիս.

  • Ձեր թեստերին և թեստային ֆունկցիաներին տվեք նկարագրական անուններ. հստակ, իմաստալից անունները հեշտացնում են տեսնել, թե ինչ է ստուգում յուրաքանչյուր թեստ, ինչը կարևոր է ձեր թեստային հավաքածուն սպասարկելու և դեբագ անելու համար։
  • Առնչվող թեստերը խմբավորեք describe ֆունկցիայով. առնչվող թեստերը միասին դնելը ձեր թեստային կոդը պահում է կազմակերպված և ավելի հեշտ ընթեռնելի։
  • Պիտակավորեք և ֆիլտրեք ձեր թեստերը tags-երով. tags-երը թույլ են տալիս դասակարգել թեստերը և աշխատեցնել դրանք ընտրովի, ինչը հատկապես օգտակար է խոշոր նախագծերում։
  • Գրեք ավելի արդյունավետ թեստեր property-based և data-driven թեստավորմամբ. այս մեթոդները օգնում են համոզվել, որ ձեր թեստերը ծածկում են մուտքերի և սցենարների լայն շրջանակ՝ ձեր թեստային հավաքածուն դարձնելով ավելի ամուր։

Համադրումը այլ տեխնոլոգիաների հետ

Որպես «բոնուս»՝ ահա մի քանի գաղափար Kotest-ը JVM-ի հանրաճանաչ backend տեխնոլոգիաների հետ օգտագործելու մասին։

Spring Boot

Սկսենք այն ամենից, ինչը անկասկած JVM-ի ամենահանրաճանաչ վեբ ֆրեյմվորքներից է՝ Spring Boot-ից։ Kotest-ը տալիս է հատուկ, պաշտոնական Spring extension։ Եթե ունեք Spring Boot Kotlin նախագիծ, Kotest-ը դրան ավելացնելը հանգում է այս կախվածությունները ձեր build ֆայլում ներառելուն (իմ դեպքում՝ Gradle, թեև Maven-ն էլ է աշխատում).

testImplementation("io.kotest:kotest-runner-junit5:$kotestVersion")
testImplementation("io.kotest.extensions:kotest-extensions-spring:$kotestSpringExtensionVersion")

Երբ դա արված է, կարող եք գրել թեստեր, որոնք համադրում են Spring Boot Test-ը Kotest-ի հետ.

@ContextConfiguration(classes = [MyConfiguration::class]) // configuration classes to use in tests
@ActiveProfiles("test") // active Spring profiles
class SpringBootKotestSampleSpec(
   orderService: OrderService // injected dependency
) : FunSpec() {
   override fun extensions() = listOf(SpringExtension) // adding Spring Extension to the test suite

   init {
       test("should find created order") {
           println("Test context is ${testContextManager().testContext}") // testContextManager is available thanks to SpringExtension

           // given
           val orderId = orderService.placeOrder() // using injected service

           // when
           val order = orderService.findOrderById(orderId)

           // then
           order.orderId shouldBe orderId
       }
   }
}

Ktor

Մեկ այլ տարբերակ Ktor կոչվող վեբ ֆրեյմվորքն է։ Սա թեթև, բայց ամբողջական ֆրեյմվորք է, գրված Kotlin-ով, բազմաթիվ plugin-ների և տարբեր հանրաճանաչ գործիքների համար extension-ների աջակցությամբ, ինչպես տարբեր DB-ներ, message broker-ներ և այլն։ Այն նույնպես աշխատում է Kotest-ի հետ՝ շնորհիվ Ktor-ի համար Kotest-ի պաշտոնական extension-ի։

Ձեր Ktor նախագծում Kotest extension-ն օգտագործելու համար պարզապես ավելացրեք այս կախվածությունները ձեր Gradle (կամ Maven) build ֆայլին.

testImplementation("io.kotest:kotest-runner-junit5:$kotestVersion")
testImplementation("io.kotest.extensions:kotest-assertions-ktor:$kotestKtorVersion")

Դրանից հետո կարող եք օգտագործել Kotest-ի հատուկ assertion-ները Ktor HTTP պատասխանների համար.

test("test greeting endpoint") {
   testApplication {
       application {
           module()
       }

       val response = client.get("/greetings/John")

       // assertions below are provided by Ktor Extension
       response.shouldHaveStatus(HttpStatusCode.OK)
       response.shouldNotHaveContentEncoding("gzip")
       response.shouldHaveHeader("Content-Type", "application/json; charset=UTF-8")
   }
}

Kotest Java նախագծում

Մինչ այժմ ես ցույց եմ տվել Kotest-ը տարբեր ֆրեյմվորքներով կառուցված Kotlin նախագծեր բերելու տարբեր եղանակներ։ Բայց ի՞նչ, եթե ձեր նախագիծը Java-ով է և ինչ-ինչ պատճառներով չեք կարող (կամ չեք ուզում) ամբողջովին անցնել Kotlin-ին։ Նույնիսկ այդ դեպքում Kotest-ը կարող է օգտակար լինել, և ես խիստ խրախուսում եմ փորձել։ Kotlin-ն ու Java-ն երկուսն էլ աշխատում են JVM-ի վրա և կարող են համագործակցել։ Այնպես որ, ոչինչ չի խանգարում արտադրական կոդը գրել Java-ով, իսկ unit թեստերի համար օգտագործել Kotlin-ը (և Kotest-ը)։ Իմ փորձով, սա նոր լեզու սովորելու և այն իրական նախագծում կիրառելու հիանալի և անվտանգ եղանակ է։ Գիտեմ, որ մարդիկ հաճախ նույնը անում են Spock-ով՝ Groovy թեստավորման ֆրեյմվորքով, այն զուգակցելով Java-ի հետ։ Ուրեմն ինչո՞ւ չփորձել Kotest-ը նման ձևով։

Լավ, ենթադրենք՝ համոզվեցիք, և ունեք Java նախագիծ Gradle build ֆայլով, որը գրված է Groovy սինտակսով։ Ինչպե՞ս սկսել unit թեստավորումը Kotest-ով այնտեղ։ Պետք է միայն փոքր փոփոխություն կատարել ձեր build.gradle ֆայլում.

plugins {
   id 'java' // this is your Java plugin, that you already have
   ... // possibly some other Gradle plugins go here
   id 'org.jetbrains.kotlin.jvm' version '2.1.10' // You need to add a Kotlin plugin for Gradle
}

dependencies {
   ...
   testImplementation("io.kotest:kotest-runner-junit5:$kotestVersion") // core dependency for Kotest
   testImplementation("io.kotest:kotest-assertions-core:$kotestVersion") // other optional dependencies for Kotest, like Kotest Assertions
   ...
}

test {
   useJUnitPlatform() // Kotest works on top of JUnit platform, so this stays unchanged
}

Maven նախագծերի դեպքում ամեն ինչ մի փոքր ավելի բարդ է, բայց դեռ կառավարելի.

<properties>
   ...
   <kotlin.version>2.1.10</kotlin.version> <!-- You can add Kotlin version as property -->
   <kotest.version>5.9.1</kotest.version> <!-- And Kotest version -->
</properties>

<build>
   <plugins>
       <plugin>
           <!-- This is Kotlin Maven plugin that you need to include -->
           <groupId>org.jetbrains.kotlin</groupId>
           <artifactId>kotlin-maven-plugin</artifactId>
           <version>${kotlin.version}</version>
           <executions>
               <execution>
                   <!--
                   As we only want to use Kotlin in tests,
                   then just test-compile goal needs to be specified 
                   -->
                   <id>test-compile</id>
                   <goals>
                       <goal>test-compile</goal>
                   </goals>
                   <configuration>
                       <sourceDirs>
                        <sourceDir>${project.basedir}/src/test/kotlin</sourceDir>
                       </sourceDirs>
                   </configuration>
               </execution>
           </executions>
       </plugin>

       <plugin>
           <!--
           As we changed the compilation process by adding Kotlin compiler,
           we also need to do some changes to a default Maven compiler
           -->
           <groupId>org.apache.maven.plugins</groupId>
           <artifactId>maven-compiler-plugin</artifactId>
           <version>3.5.1</version>
           <executions>
               <!-- Disable default compile tasks -->
               <execution>
                   <id>default-compile</id>
                   <phase>none</phase>
               </execution>
               <execution>
                   <id>default-testCompile</id>
                   <phase>none</phase>
               </execution>
               <!-- Define java-compile task which will only compile production code -->
               <execution>
                   <id>java-compile</id>
                    <phase>compile</phase>
                   <goals>
                       <goal>compile</goal>
                   </goals>
               </execution>
           </executions>
       </plugin>
   </plugins>
</build>

<dependencies>
   <!-- Here we add Kotest dependencies -->
   <dependency>
       <groupId>io.kotest</groupId>
       <artifactId>kotest-runner-junit5</artifactId>
 <version>${kotest.version}</version>
       <scope>test</scope>
   </dependency>
   <dependency>
       <groupId>io.kotest</groupId>
       <artifactId>kotest-assertions-core</artifactId>
       <version>${kotest.version}</version>
       <scope>test</scope>
   </dependency>
</dependencies>

Այսքանը։ Այժմ կարող եք գրել սովորական Kotest թեստային հավաքածուներ ձեր Java նախագծի /src/test/kotlin դիրեկտորիայում։

Ամփոփում

Ինչ երկար ճանապարհ էր։ Իմ նպատակն էր ձեզ առաջնորդել Kotest-ի՝ Kotlin-ում և Kotlin-ի համար կառուցված թեստավորման ֆրեյմվորքի բազմաթիվ հնարավորությունների միջով։ Մենք ուսումնասիրեցինք Test Framework մոդուլի հիմնական հնարավորությունները։ Ծանոթացանք Assertions Library մոդուլի տարբեր հարմար matcher-ների հետ։ Ծանոթացանք Property Testing մոդուլի տրամադրած property-based թեստավորման մոտեցմանը։ Վերջապես, փորձեցինք (հաջողությամբ) Kotest-ը համադրել մի քանի այլ JVM ֆրեյմվորքների և լեզուների հետ։

Իսկապես երկար ճանապարհ էր, բայց այն պարտադիր չէ, որ այստեղ ավարտվի։ Ձեզ համար սա կարող է լինել միայն իսկապես հետաքրքիր արկածի սկիզբը՝ Kotest-ով ձեր նախագծերում և այն ինքնուրույն հետագա ուսումնասիրելով։ Հուսով եմ՝ կզվարճանաք դրանով։