Kotest: إطار اختبار لـ Kotlin ستقع في حبه
Kotest إطار اختبار غني بالميزات وعملي ومعياري مبني بلغة Kotlin. تعرّف على ما يستطيع فعله.
Kotest إطار اختبار غني بالميزات وعملي ومعياري مبني بلغة Kotlin.
في هذا المقال سأتناول بتفصيل أكبر ما يستطيع Kotest فعله. توقّع الكثير من الأمثلة العملية والمقاطع البرمجية، فاستعد!
وحدات Kotest
يتكوّن Kotest من وحدات، وله حاليًا ثلاث وحدات رئيسية: إطار الاختبار، ومكتبة التأكيدات، واختبار الخصائص. يمكنك استخدامها جميعًا معًا، كما يمكنك اختيار ما تحتاجه فقط ودمجه مع أطر أو مكتبات اختبار أخرى.
يمكنك مثلًا استخدام تأكيدات Kotest فقط داخل اختبارات JUnit. أو كتابة الاختبارات بإطار الاختبار الأساسي في Kotest والاعتماد على AssertJ للتأكيدات. وقد ترغب أيضًا في دمج Kotest مع اختبارات Spring Boot، وهذا يعمل بسلاسة كذلك.
إطار الاختبار في Kotest
إطار الاختبار هو الوحدة المركزية في 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 فهي استدعاءات دوال توضع في كتلة init داخل صنف Spec. وبالجوهر، يمنحنا Kotest لغة DSL لكتابة الاختبارات. وهذه التفصيلة التي تبدو ثانوية تتيح ميزة قوية: توليد حالات الاختبار ديناميكيًا أثناء التشغيل.
يمكننا مثلًا كتابة شيء كهذا:
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
}
}
})
وهكذا ببساطة بنينا مجموعة اختبارات ديناميكية تأتي حالات الاختبار فيها من ملفات نصية خارجية ذات محتوى مخصص.
هذا مثال واحد فقط بالطبع، وهناك طرق إبداعية كثيرة للاستفادة من هذه الميزة. أليس هذا رائعًا؟!
خطافات دورة الحياة والامتدادات
إلى جانب أنماطه المتعددة، يأتي Kotest أيضًا بآلية مرنة من خطافات دورة الحياة والامتدادات. وهي تشمل كل الخطافات المعتادة المألوفة من أطر الاختبار الأخرى، مثل beforeSpec, afterSpec, beforeTest, afterTest، وغيرها. وفوق ذلك، يمكننا بسهولة كتابة امتداداتنا وخطافاتنا الخاصة وتوصيلها.
التقييم الشرطي
يوفر Kotest وسائل قوية لـتشغيل الاختبارات بشروط. لديك خيارات كثيرة، من مجرد تعطيل حالات اختبار معينة إلى تشغيل تلك التي تستوفي شروطًا معقدة تُفحص أثناء التشغيل فقط. يوضح المثال أدناه ما هو ممكن هنا:
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 عدة طرق لهيكلة الاختبارات وتصفيتها، ما يفيد عند التعامل مع مجموعات اختبار كبيرة والتركيز على أجزاء معينة من قاعدة الشيفرة.
من الميزات المحورية لهيكلة الاختبارات الدالة describe في DescribeSpec، التي تتيح لك وضع الاختبارات المترابطة في مجموعة واحدة. يساعد ذلك على تنظيم شيفرة الاختبار بحيث تعكس الوظيفة قيد الاختبار، ما يسهّل قراءتها وصيانتها.
فيما يلي مثال على تجميع الاختبارات بالدالة 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 أيضًا وسم الاختبارات وتصفيتها باستخدام الوسوم. يمكنك استخدام الوسوم لتصنيف الاختبارات حسب أمور مثل الوظيفة أو الأولوية أو البيئة. وبناءً على هذه الوسوم يمكنك بعدها تضمين اختبارات في التشغيل أو استبعادها، وهو ما يفيد خصوصًا في المشاريع الكبيرة ذات مجموعات الاختبار الضخمة.
وهكذا يمكن وسم الاختبارات:
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 والوسوم، يمكنك تنظيم اختباراتك وتصفيتها بكفاءة، ما يسهّل إدارتها وتشغيلها متى احتجت.
دعم الكوروتينات
كما تتوقع من إطار مبني بلغة Kotlin ولأجلها، يوفر Kotest دعمًا للكوروتينات جاهزًا للاستخدام. يمكن تشغيل حالات الاختبار داخل coroutineTestScope، المفعّل إما في دالة config الخاصة بحالة اختبار واحدة أو بشكل عام لكل حالات الاختبار في المواصفة. ثم يعمل الاختبار على TestDispatcher توفره مكتبة kotlinx.coroutines، ما يتيح لنا التحكم في الوقت الافتراضي داخل الاختبارات وتخطي التأخيرات وغير ذلك.
كوروتينات Kotlin موضوع واسع إلى حد لن أخوض معه في مزيد من التفاصيل في هذا المقال. لكن تابعوا مدونتنا لمقالات أخرى عن الكوروتينات، يُفترض نشرها هناك قريبًا.
الاختبار المعتمد على البيانات
ربما تعرف الاختبارات ذات المعاملات من أطر اختبار أخرى (مثل @ParameterizedTest في JUnit 5 أو الكلمة المفتاحية where في Spock). تستند الاختبارات المعتمدة على البيانات في Kotest إلى المفهوم نفسه. والفكرة وراءها هي:
- كتابة حالة اختبار تأخذ معاملات،
- تحضير عدة مجموعات من تلك المعاملات،
- تشغيل حالة الاختبار مع كل مجموعة معاملات، مع توقع نجاحها في كل مرة.
قبل استخدام الاختبار المعتمد على البيانات، عليك أولًا إضافة هذه الاعتمادية إلى ملف بناء Gradle:
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 الأساسية. لننظر الآن في الميزات الرائعة الأخرى التي توفرها الوحدتان المتبقيتان.
مكتبة التأكيدات
أهم جزء في أي اختبار هو التأكيدات. ربما ستندهش لو أخبرك أحدهم أن مشروعه يحقق تغطية شيفرة بنسبة 100% وأن كل الاختبارات تنجح دائمًا. لكن هذه الدهشة ستزول لحظة إضافته أن أيًا من اختباراته لا يحتوي على تأكيدات.
لحسن الحظ، يأتي Kotest مع مكتبة تأكيدات واسعة لأنواع بيانات كثيرة. وبفضل السكّر النحوي المدمج في Kotlin، فإن تأكيدات Kotest أيضًا معبّرة جدًا وعملية ومقروءة.
لاستخدام مكتبة التأكيدات في مشروعك، أضف الاعتمادية المقابلة إلى ملف البناء:
testImplementation("io.kotest:kotest-assertions-core:$kotestVersion")
المطابِقات
تشكّل المطابِقات (Matchers) العمود الفقري لوحدة تأكيدات Kotest. فكّر في المطابِق على أنه دالة تتحقق مما إذا كانت قيمة ما تطابق ما تتوقعه. يأتي Kotest بالكثير من المطابِقات المدمجة. وإليك بعضها:
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")
}
ربما لاحظت أنني استخدمت، بين المطابِقات الأخرى في المثال أعلاه، shouldContainJsonKey. وهو مطابِق خاص، إذ ينتمي إلى مطابِقات JSON. ولاستخدامه أو أي مطابِق JSON آخر، عليك إضافة اعتمادية أخرى إلى ملف البناء:
testImplementation("io.kotest:kotest-assertions-json:$kotestVersion")
المفتّشات
لدى Kotest أيضًا واجهة برمجية مخصصة لفحص عناصر المجموعات. وتتيح لك هذه الواجهة، المسماة المفتّشات (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 }
}
المطابِقات المخصصة
إذا كانت المكتبة القياسية لا تزال تفتقر إلى مطابِق تحتاجه، يمكنك كتابة مطابِقك الخاص. وتذكّر أن دوال الامتداد في Kotlin والدوال الوسيطة (infix) متاحة لك بالكامل لهذا الغرض!
كل ما يلزم هو تعريف دالة (أو عدة دوال) تعمل كمطابِق:
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
}
وفي الاختبارات، تُستخدم هذه المطابِقات بعد ذلك هكذا:
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
}
المطابِقات المركّبة
يتيح لنا Kotest أيضًا دمج مطابِقات مختلفة (مدمجة ومخصصة) في مطابِقات مركّبة. وبهذا يمكننا ضم شروطنا في شروط أكثر تعقيدًا والتحقق إما من تحقق كل الشروط أو من تحقق واحد منها على الأقل.
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
}
التأكيدات الناعمة
ميزة أخرى صغيرة لكنها عملية في Kotest هي دعم التأكيدات الناعمة. افتراضيًا، يشغّل Kotest حالات الاختبار باستراتيجية الفشل السريع، أي أن تنفيذ الاختبار يتوقف عند أول تأكيد يفشل. أما هذه الميزة الصغيرة فتتيح لك تشغيل كل التأكيدات سواء فشل بعضها أم لا. وستفشل حالة الاختبار بالطبع إن فشل أي تأكيد؛ والتغيير الوحيد هو أن كل التأكيدات تُفحص بغض النظر عن ذلك.
test("soft assertions") {
val text = "Some text"
assertSoftly {
text shouldContain "no such string"
text shouldStartWith "S"
text shouldHaveLength 100
}
}
الاختبار غير الحتمي
عند كتابة اختبارات الوحدة، نود مثاليًا أن تتصرف الشيفرة قيد الاختبار بشكل متوقع تمامًا وأن تعمل فورًا. للأسف ليس الأمر كذلك دائمًا. أحيانًا علينا اختبار عمليات غير متزامنة لا نعرف عنها سوى أنها ينبغي أن تكتمل في وقت ما. كيف نتعامل مع ذلك؟ الاختبار غير الحتمي في 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. لكن لا يزال هناك شيء مثير آخر أريد أن أريكم إياه: الوحدة الأخيرة في Kotest – اختبار الخصائص.
اختبار الخصائص
تعتمد اختبارات الوحدة التي يكتبها المطورون عادةً على الأمثلة – إذ تمرّر مدخلات عينة إلى الكائن قيد الاختبار وتتوقع نتائج معينة. يُعرف هذا بـالاختبار المبني على الأمثلة. وهو جيد في معظم الأوقات، لكن له نقاط ضعفه. فمثلًا، قد تغفل أمثلتنا بسهولة بعض الحالات الحدّية. كما أن تعريف بيانات اختبار وهمية أكثر تعقيدًا يدويًا قد يكون مملًا. لكن هذه ليست الطريقة الوحيدة لاختبار الشيفرة – فهناك نهج آخر هو الاختبار المبني على الخصائص، ويدعمه Kotest أيضًا.
في الاختبار المبني على الخصائص، تُولَّد بيانات اختبار عشوائية تغطي الحالات الحدّية والنموذجية تلقائيًا، ويُشغَّل الاختبار مرات عديدة باستخدام تلك البيانات المولَّدة مدخلات.
لاستخدام اختبار الخصائص في مشروعك، أضف الاعتمادية التالية إلى ملف بناء Gradle:
testImplementation("io.kotest:kotest-property:$kotestVersion")
دوال اختبار الخصائص
لتوضيح كيفية كتابة اختبارات الخصائص في Kotest، إليك بعض اختبارات الخصائص لدالة فيبوناتشي:
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. لنستعرضها واحدة تلو الأخرى:
- هذه حالة اختبار أساسية مبنية على الخصائص. العنصر الجوهري هو الدالة
forAll، التي تشغّل جسمها مرات عديدة (1000 مرة افتراضيًا). وArb.int(2..10)مولِّد يخبر Kotest بالقيم التي ينبغي تغذية الاختبار بها. هنا سيكون n دائمًا رقمًا عشوائيًا من 2 إلى 10. وبدون تحديد مولِّد، سيولّد Kotest افتراضيًا أرقامًا منInt.MIN_VALUEإلىInt.MAX_VALUE. ومما يجدر معرفته عنforAllأيضًا أنها تأخذ لامدا من النوع(a, …, n) -> Boolean، وكي ينجح الاختبار يجب أن يُرجع كل استدعاء للامدا القيمة true. - تشبه حالة الاختبار هذه سابقتها كثيرًا، مع فرقين رئيسيين. أولًا، نعرّف اختبارنا المبني على الخصائص بالدالة
checkAllبدلًا منforAll. تأخذCheckAllلامدا من النوع(a, …, n) -> Unit، لذا يمكننا فحص شروطنا بالتأكيدات – ولا حاجة لإرجاع قيمة منطقية كما فيforAll. ثانيًا، نحدد عدد تكرارات الاختبار صراحةً، وهو هنا 100. ويختلف الجسم أيضًا قليلًا بالطبع، إذ نفحص الآن نتيجة الدالة بالتأكيدات بدلًا من إرجاع قيم منطقية. - عند النظر إلى حالتي الاختبار السابقتين، قد تتساءل: «لماذا نشغّل 1000 أو حتى 100 تكرار بأرقام عشوائية لمجرد اختبار دالة فيبوناتشي الحتمية للقيم من 2 إلى 10؟». ولديك حق في ذلك – فهناك خيار أفضل لهذه الحالة تحديدًا، تعرضه حالة الاختبار رقم 3. لاحظ أننا بدلًا من المولِّد العشوائي للمعامل n نستخدم هنا
Exhaustive.ints(2..10). ونتيجة لذلك يولّد Kotest كل قيمة من المدى المعطى ويشغّل حالة الاختبار مرة واحدة بالضبط لكل قيمة. فبدلًا من 1000 أو 100 تشغيل، نحصل على 9 تكرارات تغطي كل قيمة في المدى 2-10. - لا تقدّم حالة الاختبار الرابعة كثيرًا من ميزات Kotest الجديدة مقارنة بالسابقات. بل تعرض أساسًا صيغة أخرى من المولِّد العشوائي لـ
Ints(مجموعة نصف مفتوحة من قيم Int، منInt.MIN_VALUEإلى -1). كما توضح أنه يمكن اختبار الاستثناءات في حالة اختبار مبنية على الخصائص.
عمليات المولِّدات
قدّم القسم السابق بعض المولِّدات. أصبحت تعرف الآن أن المولِّدات Arb أو Exhaustive يمكنها إنتاج البيانات لاختباراتنا المبنية على الخصائص. وعما قريب (تنبيه حرق!) ستتعرف أيضًا على المولِّدات المخصصة.
لكنك سترى في هذا القسم أن حتى المولِّدات المدمجة تأتي بعمليات مفيدة تتيح لنا تكييفها وفق احتياجاتنا – من مجرد أخذ العنصر التالي من مولِّد إلى التصفية والتحويل المتطورين لتدفقات القيم التي تنتجها المولِّدات. وهذه بعض الأمثلة:
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)
إعلانات الأنواع ليست لازمة هنا. أضفتها فقط لأوضح أن معظم عمليات المولِّدات تُرجع مولِّدات أيضًا، لذا يمكننا استخدامها في اختبارات الخصائص كالمعتاد أو تحويلها وتحويرها أكثر. وتبرز العملية next، إذ تجلب، كما ترى، قيمة فعلية من مولِّد.
الافتراضات
في بعض الأحيان لا تكون كل توليفة من معاملات الإدخال منطقية لحالة اختبار. وهنا يأتي دور الافتراضات. فهي الأداة المناسبة حين نريد تخطي بعض تكرارات حالة الاختبار تبعًا لمعاملاتها. ويمكن التعبير عن الافتراضات بتعبير شرطي أو حتى بالتأكيدات. وهذه بعض الأمثلة:
"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
}
}
المولِّدات المخصصة
كما ألمحت سابقًا، اختباراتنا المبنية على الخصائص ليست مقيدة بمولِّدات معرّفة مسبقًا. فـKotest يتيح لنا كتابة مولِّدات مخصصة خاصة بنا. وفي رأيي أن هذا مفيد بصفة خاصة حين نريد توليد نسخ من أصنافنا الخاصة.
يمكن تنفيذ مولِّدات عشوائية وشاملة على السواء. ويوضح المقطع البرمجي أدناه كيف:
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 تمامًا كما نولّد Ints أو Strings واستخدامها في حالات اختبار مبنية على الخصائص. ولا شيء يمنعنا من استخدام البيانات المولَّدة بهذه الطريقة في حالات اختبار عادية أيضًا. فكلما فضّلنا ألا نعرّف بيانات الاختبار يدويًا، يمكننا ببساطة توليدها.
هذا كل ما في وحدة اختبار الخصائص في Kotest. آمل أن تكون هذه المعلومات مفيدة وممتعة.
أفضل الممارسات
فيما يلي بعض أفضل الممارسات التي تستحق التذكر عند العمل مع Kotest:
- امنح اختباراتك ودوال الاختبار أسماء وصفية: الأسماء الواضحة ذات المعنى تسهّل معرفة ما يفحصه كل اختبار، وهذا ضروري لصيانة مجموعة اختباراتك وتصحيح أخطائها.
- جمّع الاختبارات المترابطة بالدالة
describe: وضع الاختبارات المترابطة معًا يُبقي شيفرة الاختبار منظمة وأسهل قراءة. - وسّم اختباراتك وصفّها بالوسوم: تتيح لك الوسوم تصنيف الاختبارات وتشغيلها انتقائيًا، وهو مفيد خصوصًا في المشاريع الكبيرة.
- اكتب اختبارات أكثر فعالية بالاختبار المبني على الخصائص والاختبار المعتمد على البيانات: تساعد هاتان التقنيتان على ضمان أن اختباراتك تغطي نطاقًا واسعًا من المدخلات والسيناريوهات، ما يجعل مجموعة اختباراتك أكثر متانة.
الدمج مع تقنيات أخرى
كـ«مكافأة»، إليك بعض الأفكار حول استخدام Kotest مع تقنيات الواجهة الخلفية الشائعة على JVM.
Spring Boot
لنبدأ بما هو بلا شك أحد أشهر أطر الويب على JVM: Spring Boot. يوفر Kotest امتدادًا رسميًا مخصصًا لـ Spring. إذا كان لديك مشروع Spring Boot بلغة Kotlin، فإن إضافة Kotest إليه تتلخص في تضمين هذه الاعتماديات في ملف البناء (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، يدعم الكثير من الإضافات والامتدادات لمجموعة متنوعة من الأدوات الشائعة، مثل قواعد البيانات المختلفة ووسطاء الرسائل وغيرها. كما يعمل مع Kotest بفضل امتداد Kotest الرسمي لـ Ktor.
لاستخدام امتداد Kotest في مشروع Ktor، أضف هذه الاعتماديات إلى ملف بناء Gradle (أو Maven):
testImplementation("io.kotest:kotest-runner-junit5:$kotestVersion")
testImplementation("io.kotest.extensions:kotest-assertions-ktor:$kotestKtorVersion")
بعد ذلك يمكنك استخدام تأكيدات Kotest المخصصة لاستجابات HTTP في Ktor:
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 واستخدام Kotlin (وKotest) لاختبارات الوحدة. وبحسب خبرتي، هذه طريقة رائعة وآمنة لتعلم لغة جديدة وتطبيقها فعليًا في مشروع حقيقي. وأعلم أن الناس كثيرًا ما يفعلون الشيء نفسه مع Spock، وهو إطار اختبار بلغة Groovy، بإقرانه مع Java. فلماذا لا نجرّب Kotest بطريقة مماثلة؟
حسنًا، لنفترض أنك اقتنعت ولديك مشروع Java مع ملف بناء Gradle مكتوب بصياغة Groovy. كيف تبدأ اختبار الوحدة بـ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 عادية في المجلد /src/test/kotlin من مشروع Java الخاص بك.
الخلاصة
يا لها من رحلة طويلة! كان هدفي أن أرشدك عبر الميزات العديدة لـKotest – إطار اختبار مبني بلغة Kotlin ولأجلها. استكشفنا الميزات الأساسية لوحدة إطار الاختبار. وتعرّفنا على مجموعة متنوعة من المطابِقات العملية من وحدة مكتبة التأكيدات. وتعرفنا على نهج الاختبار المبني على الخصائص الذي توفره وحدة اختبار الخصائص. وأخيرًا حاولنا (بنجاح!) دمج Kotest مع بعض أطر ولغات JVM الأخرى.
لقد كانت رحلة طويلة حقًا، لكن لا يلزم أن تتوقف هنا. فقد تكون بالنسبة إليك مجرد بداية مغامرة مثيرة حقًا مع Kotest في مشاريعك ومع استكشافه أكثر بنفسك! أتمنى لك الاستمتاع به!