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