7 مكتبات وأطر عمل Kotlin تستحق المعرفة لتطوير الواجهة الخلفية
تعرّف على مكتبات وأطر عمل Kotlin الأصيلة المكتوبة بالكامل بهذه اللغة والمبنية خصيصاً لها.
أكاد أجزم بأن لغة البرمجة الحديثة التي تفتقر إلى منظومة غنية من المكتبات وأطر العمل ستنتهي عاجلاً أم آجلاً إلى مجرد لعبة أنيقة لا تُستخدم في الواقع العملي.
لحسن الحظ، Kotlin بعيدة كل البعد عن هذا الوضع. لماذا؟ أولاً، بفضل قابلية التشغيل البيني الممتازة بين Kotlin وJava – إذ يمكن استخدام منظومة Java بأكملها من Kotlin بكل سهولة. وثانياً، بفضل العدد الكبير أصلاً من مكتبات وأطر عمل Kotlin الأصيلة، المكتوبة بالكامل بهذه اللغة والمبنية خصيصاً لها.
حسناً، ها أنت تقرأ هذا المقال. ربما أنت مطوّر Java للواجهة الخلفية قرر للتو تجربة Kotlin في مشروعك القادم. أو ربما أنت مطوّر Kotlin للهواتف المحمولة تعرف Kotlin بالفعل وتريد الانتقال إلى تطوير الواجهة الخلفية دون التخلي عن لغتك المفضلة. وفي الحالتين، قد تتساءل: هل بين المكتبات وأطر العمل المذكورة أعلاه ما هو أصيل في Kotlin ويتيح لك الاستفادة من الإمكانات الكاملة لـ Kotlin في الواجهة الخلفية؟
الإجابة المختصرة: نعم.
والإجابة الأطول: نعم، بالتأكيد.
دعنا نستكشف معاً بعضاً من أفضل مكتبات وأطر عمل Kotlin المتاحة، والتي ستساعدك على بناء تطبيقات واجهة خلفية جاهزة للإنتاج وعلى مستوى المؤسسات بكفاءة وبأسلوب Kotlin!
Ktor – إطار عمل Kotlin لبناء تطبيقات الويب
حسب ما رأيت، يشير «تطوير الواجهة الخلفية» عادةً إلى تطبيقات الويب أو الخدمات المصغّرة. ولذلك، لدعم تطوير الواجهة الخلفية، يجب أن تتوفر للغة البرمجة أطر عمل ويب شاملة. وKotlin ليست استثناءً.
إذا كانت خلفيتك في Java، فربما يكون Spring Boot أول إطار عمل ويب يخطر ببالك. قد تسأل حينها: هل يمكنني ببساطة كتابة تطبيقات Kotlin باستخدام Spring Boot؟ اطمئن – بالتأكيد يمكنك ذلك، وهي ممارسة شائعة إلى حد ما – فـ Spring Boot يعمل بشكل ممتاز مع Kotlin. لكن إذا أردت الذهاب أبعد والاستفادة الكاملة من Kotlin عند بناء تطبيقك القادم من جهة الخادم، فقد يكون إطار عمل Ktor ما تحتاج إليه تماماً.
Ktor هو إطار عمل لبناء تطبيقات الويب أنشأته JetBrains، أي من أوجدوا Kotlin نفسها. وهذا وحده يدل على أن الإطار واللغة مصممان للعمل بتناغم وتكامل مزايا كل منهما. ويتضح ذلك بمجرد أن نبدأ كتابة الشيفرة باستخدام Ktor: الكوروتينات، ودوال الامتداد (extension functions)، ودوال lambda الختامية (trailing lambdas) – كل هذه المزايا من Kotlin مواطنون من الدرجة الأولى وهي أسس Ktor.
كما يسعى Ktor إلى أن يكون خفيف الوزن وبسيطاً قدر الإمكان. فهو مبني مع وضع اللاتزامنية في الاعتبار، ويمكنه العمل في أي حاوية servlet تدعم واجهة Servlet 3.0+ API، مثل Tomcat، أو بشكل مستقل مع Netty أو Jetty. ألقِ نظرة على المقطع أدناه، الذي يعرض تطبيق Ktor بسيطاً يقدّم نقطة نهاية REST:
fun main(args: Array<String>) {
io.ktor.server.netty.EngineMain.main(args)
}
fun Application.module() {
install(ContentNegotiation) {
json()
}
routing {
get ("/greetings/{name}") {
val name = call.parameters["name"] ?: "Anonymous"
call.respond(Greeting("Hello $name!"))
}
}
}
@Serializable
data class Greeting(val message: String)
وبطبيعة الحال، Ktor قادر على ما هو أكثر من ذلك بكثير. فهو إطار عمل معياري (modular) تقوم فلسفته على أن يختار مطورو Kotlin بدقة ما يحتاجه تطبيقهم دون أي شيء زائد. وبناءً على ذلك، يوفر Ktor إضافات (plugins) كثيرة يمكن إضافتها إلى المشروع عند إنشائه أو لاحقاً، على شكل إضافات واعتمادات Gradle. وكتالوج الإضافات المتاحة واسع بالفعل، ويقدم إضافات في فئات مثل الأمان وHTTP والمراقبة وقواعد البيانات وغيرها الكثير.
وإلى جانب ذلك، يوفر Ktor كثيراً من المزايا الأخرى التي تتوقعها من إطار ويب ناضج، ومنها:
- الإعداد القائم على الخصائص
- دعم HTTP/2 (مع شهادات SSL)
- التفاوض على المحتوى والتسلسل
- Web sockets
- مجموعة من مكتبات القوالب
- جلسات HTTP
وتماماً مثل Spring Boot، يأتي Ktor مع أداة مفيدة لإنشاء المشاريع. فهي تتيح لك إعداد البنية الأولية لمشروعك وتوليدها بسرعة، مع الاعتمادات المطلوبة وملفات الإعداد وشيفرة نموذجية. ويمكنك استخدام الأداة إما في المتصفح أو مباشرة من IntelliJ IDEA.
يستحق Ktor بلا شك مقالاً مستقلاً، ونعمل حالياً على شيء من هذا القبيل، فترقّبوا!
Koin – إطار عمل خفيف لحقن الاعتمادات في Kotlin
ما لم تكن قد دخلت مجال تطوير البرمجيات بالأمس، فقد صادفت بالتأكيد مفهوم حقن الاعتمادات (Dependency Injection – DI). هذا المفهوم، المرتبط بشكل فضفاض بمبدأ عكس الاعتماديات (Dependency Inversion) من مبادئ SOLID الشهيرة لـ Uncle Bob Martin، تبنته وطبقته مكتبات وأطر عمل كثيرة، وهو اليوم واسع الانتشار في الصناعة. يكفي أن نذكر أن Spring نفسه بدأ كحاوية لحقن الاعتمادات، قبل أن ينمو في النهاية إلى إطار عمل بهذا الحجم والتنوع حتى كاد يحتاج إلى إطار عمل خاص به (نعم، أقصدك يا Spring Boot!). فليس من المستغرب أن يكون لدى Kotlin جواب في هذا المجال أيضاً. تعرّف على Koin – إطار عمل خفيف لحقن الاعتمادات في Kotlin.
كما هو الحال مع كل مكتبة وإطار عمل نتناولها هنا، Koin مكتوب بالكامل بلغة Kotlin. ولذلك فإن من نقاط قوته وبيعه صياغته الموجزة جداً بأسلوب Kotlin، التي تعتمد بكثافة على نهج يشبه DSL في كتابة الشيفرة.
ومن الجوانب الرائعة الأخرى في Koin أنه متعدد المنصات بتصميمه. يمكنك استخدامه في تطبيقات جهة الخادم، سواء كانت Kotlin عادية أو Ktor، وكذلك في تطبيقات جهة العميل – Android الأصيل أو Jetpack Compose أو تطبيقات الهواتف متعددة المنصات. بل إن وثائق Koin الرسمية تصف حالات الاستخدام هذه صراحةً.
لنلقِ نظرة على أبسط استخدام لـ Koin في تطبيق واجهة خلفية عادي، باستخدام نهج Koin DSL:
interface GreetingService { // 1
fun sayHello(name: String)
}
class GreetingServiceImpl : GreetingService { // 2
override fun sayHello(name: String) = println("Hello $name!")
}
val greetingsModule = module { // 3
single<GreetingService> { GreetingServiceImpl() }
}
class GreetingsApplication : KoinComponent { // 4
private val greetingsService: GreetingService by inject() // 5
fun run() = greetingsService.sayHello("Rupert")
}
fun main() {
startKoin { // 6
modules(greetingsModule)
}
GreetingsApplication().run()
}
هناك بضع مراحل رئيسية هنا:
- نعلن عن واجهة (interface) ستكون العقد الخاص باعتمادنا. لاحظ أن هذه الخطوة اختيارية: إذ يمكن حقن التنفيذات الفعلية كاعتمادات مباشرة دون واجهات وسيطة.
- بعد ذلك نوفر التنفيذ الفعلي لتلك الواجهة.
- هنا يدخل Koin المشهد لأول مرة – فمن خلال تعريف وحدة (module) نربط التنفيذات الفعلية بجميع اعتماداتنا. في هذه الحالة نحدد أن الواجهة
GreetingServiceستكون كائناً وحيداً (singleton) مدعوماً بالصنفGreetingServiceImpl. وإلى جانب الكائنات الوحيدة، يمكن تعريف مصانع (factories) أيضاً. ومن الجدير بالذكر كذلك أن Koin يتيح لنا تعريف عدة وحدات بمجموعات اعتمادات مختلفة. - لحقن الاعتمادات التي يديرها Koin، نحتاج إلى صنف يمتد من
KoinComponent. هنا هوGreetingsApplication، لكنه قد يكون أي صنف نقطة دخول في التطبيق، مثل متحكم REST أو مستمع أحداث JMS. - هكذا يتم تشغيل حقن الاعتمادات فعلياً في Koin. داخل
KoinComponent، يمكن حقن أي اعتماد معرّف في أي وحدة Koin باستخدام دالة التفويض by inject(). - وأخيراً، لكي يعمل كل شيء، يجب تشغيل حاوية Koin عند نقطة الدخول الرئيسية. تأخذ الدالة
startCoinجميع الوحدات التي نريد تضمينها في التطبيق، وتتيح لنا أيضاً إعدادها بشكل إضافي، مثلاً بتحديد مسجّل أحداث (logger) أو خصائص خارجية.
وإذا كنت تحب «سحر» التعليقات التوضيحية (annotations)، فـ Koin يلبّي ذلك أيضاً. يمكن تحقيق النتيجة نفسها أعلاه باستخدام annotations:
interface GreetingService { // 1
fun sayHello(name: String)
}
@Single
class GreetingServiceImpl : GreetingService { // 2
override fun sayHello(name: String) = println("Hello $name!")
}
@Module
@ComponentScan("org.example")
class GreetingsModule // 3
class GreetingsApplication : KoinComponent { // 4
private val greetingsService: GreetingService by inject() // 5
fun run() = greetingsService.sayHello("Rupert")
}
fun main() {
startKoin { // 6
modules(GreetingsModule().module)
}
GreetingsApplication().run()
}
إليك ما يحدث:
- لا جديد – نعلن عن واجهة للاعتماد تماماً كما في المثال السابق.
- التنفيذ الفعلي للواجهة. لكن هذه المرة يحمل
GreetingServiceImplالتعليق التوضيحي @Single. وهذه هي الطريقة القائمة على annotations للقول إن هذا الصنف سيكون اعتماداً من نوع singleton مرتبطاً بالواجهةGreetingService. - في هذه الخطوة نعرّف صنف وحدة. وهو يعمل كعلامة تخبر Koin بنطاق الوحدة والمكان الذي يبحث فيه عن المكونات (أي الأصناف المُعلَّمة) التابعة لها.
- يمكن حقن الاعتمادات في
KoinComponent. وهذا مطابق للمثال الذي لا يستخدم annotations. - التعليقات التوضيحية لا تغيّر إلا طريقة تعريف الاعتمادات، لا طريقة حقنها، لذا يطابق هذا السطر نسخة DSL من واجهة Koin API.
- مرة أخرى نشغّل حاوية Koin مع الوحدات. لكن لاحظ كم تختلف طريقة تمرير الوحدات هذه المرة عن المثال السابق. فهنا نصل إلى خاصية
moduleفي الصنفGreetingsModuleالمعرّف في الخطوة 3. لاحظ أن الصنف لا يعلن عن مثل هذه الخاصية ولا يمتد من أي شيء. وهنا يظهر سحر annotations – فـ Koin يعتمد على إضافة KSP (Kotlin Symbol Processing) التي تقرأ تعليقات Koin التوضيحية وتولّد الدوال والخصائص اللازمة وقت الترجمة.
بهذا نكون قد غطينا أساسيات Koin. وللتذكير – كما قلت سابقاً، Koin قابل للتشغيل البيني الكامل مع إطار عمل Ktor، لذا يمكن الجمع بينهما بسلاسة لبناء تطبيقات الويب بكفاءة أكبر.
Exposed – إطار عمل خفيف للاستمرارية يعتمد على SQL وORM
من الصعب تخيّل نظام معلومات دون استمرارية للبيانات (persistence). فعاجلاً أم آجلاً سيتعين على تطبيق الواجهة الخلفية لديك تخزين بعض البيانات. وبما أن قواعد البيانات العلائقية ما زالت الأكثر شعبية اليوم، فمن المرجح أنك تريد إطار عمل متيناً للاستمرارية قائماً على SQL عند العمل مع Kotlin. ولحسن الحظ هناك إطار يناسب ذلك تماماً: Exposed.
Exposed هو إطار عمل خفيف للاستمرارية يعتمد على SQL وORM ومكتوب بلغة Kotlin. وهو مثل Ktor تتولى صيانته JetBrains – الشركة التي تقف، للتذكير، وراء لغة Kotlin نفسها.
يعمل Exposed فوق مشغّل JDBC الخاص بـ Kotlin، ويدعم وقت كتابة هذا المقال قواعد البيانات التالية: H2 وMariaDB وMySQL وOracle وPostgreSQL وMicrosoft SQL Server وSQLite. ولا يتطلب إعداد الاتصال بقاعدة البيانات سوى هذا:
Database.connect("jdbc:h2:mem:test", driver = "org.h2.Driver")
المعامل الأول هو عنوان URL للاتصال، والثاني هو مشغّل قاعدة البيانات. وهذه بالطبع إحدى الطرق – وأبسطها – لإعداد الاتصال بقاعدة البيانات. وهناك أيضاً استدعاءات أكثر تفصيلاً لـ Database.connect() تأخذ معاملات أكثر. وعلاوة على ذلك، يمكن إعداد الاتصال بقاعدة البيانات بتمرير كائن javax.sql.DataSource إلى Database.connect()، مما يتيح الوصول إلى جميع ميزات الإعداد المتقدمة للاتصال التي يوفرها DataSource، مثل تجميع الاتصالات (connection pooling).
وإلى جانب إعداد الاتصال بقاعدة البيانات، نحتاج أيضاً إلى بعض جداول قاعدة البيانات للعمل عليها. إليك كيف يُعرَّف جدول باستخدام Exposed:
const val VARCHAR_LENGTH = 128
object Employees: IntIdTable("employees") {
val firstName = varchar("first_name", VARCHAR_LENGTH)
val lastName = varchar("last_name", VARCHAR_LENGTH)
val email = varchar("email", MAX_VARCHAR_LENGTH).uniqueIndex()
val isFullTime = bool("full_time").default(true)
}
يحتوي الجدول النموذجي أعلاه على أعمدة من أنواع بسيطة فقط، لكن Exposed يقدم أيضاً بعض الامتدادات الاختيارية التي تتيح لنا استخدام أنواع بيانات أكثر تعقيداً وتخصصاً، مثل البيانات المشفرة والتاريخ والوقت وJSON والمال.
حسناً، أصبح لدينا الآن إعداد اتصال بقاعدة البيانات وجدول. حان وقت الاستعلامات! من أكثر جوانب Exposed إثارة للاهتمام أنه يتيح لمطوري Kotlin اختيار أسلوب التعامل مع قاعدة البيانات الذي يفضلونه: SQL DSL أو ORM خفيف مع DAO وكيانات (entities). فيما يلي بضعة مقاطع شيفرة صغيرة جداً، لمجرد إعطائك فكرة عن شكل هذين الأسلوبين في الوصول إلى قاعدة البيانات في Exposed.
أولاً، لننظر إلى SQL DSL، وهي الطريقة الافتراضية في Exposed للاستعلام عن قاعدة البيانات:
// insert
val employeeId = Employees.insert {
it[firstName] = "John"
it[lastName] = "Doe"
it[email] = "john.doe@example.com"
} get Employees.id
// select all
val allEmployees = Employees.selectAll().toList()
// select aggregated
Employees.select(Employees.id.count(), Employees.isFullTime)
.groupBy(Employees.isFullTime).forEach {
println("${it[Employees.isFullTime]}: ${it[Employees.id.count()]} ")
}
// update
Employees.update({ Employees.id eq employeeId }) {
it[isFullTime] = false
}
// select single row
val updatedEmployee = Employees.select(
Employees.firstName,
Employees.lastName,
Employees.isFullTime
).where(Employees.id eq employeeId).single()
// delete
Employees.deleteWhere { id eq employeeId }
بعد ذلك، لنرَ كيف يمكن التعامل مع البيانات في جدول employees باستخدام Exposed DAO. في البداية علينا تعريف صنف كيان لـ Employee:
class EmployeeEntity(id: EntityID<Int>) : IntEntity(id) {
companion object : IntEntityClass<EmployeeEntity>(Employees)
var firstName by Employees.firstName
var lastName by Employees.lastName
var email by Employees.email
var isFullTime by Employees.isFullTime
}
وبعد أن أصبح الكيان جاهزاً، يمكننا إجراء عمليات مختلفة عليه:
// insert
val employee = EmployeeEntity.new {
firstName = "John"
lastName = "Doe"
email = "john.doe@example.com"
}
// select all
val allEmployees = EmployeeEntity.all().toList()
// update
employee.isFullTime = false // this will be flushed to the DB at the end of transaction
val updatedEmployee = EmployeeEntity.findByIdAndUpdate(employee.id.value) {
it.email = "john.doe@newdomain.com"
}
// select single row
val foundEmployee = EmployeeEntity.findById(employee.id.value)
// delete
employee.delete()
ومن الجدير بالذكر أيضاً أن Exposed مدعوم بالكامل من إطار عمل Ktor ويُقدَّم كإحدى إضافاته.
هل تريد معرفة المزيد عن إطار عمل Exposed؟ ترقّب مقالاتنا القادمة عن Exposed!
Kotest – إطار عمل للاختبار في Kotlin
لا أظن أن من المبالغة القول إنه يصعب تخيّل برمجيات بلا اختبارات في أيامنا هذه (إلا إذا كانت إثبات مفهوم PoC أو نموذجاً أولياً من نوع ما). لذلك فإن إطار عمل اختبار موثوقاً ومريحاً أمر أساسي لكل لغة برمجة. فهل لدى Kotlin واحد؟
سيداتي وسادتي، أقدّم لكم Kotest!
قبل التعمق في مزايا Kotest، دعني أتوقف لحظة لأتناول سؤالاً أو شكاً ربما خطر ببالك للتو: إذا كانت Kotlin تعمل بهذه السلاسة مع Java، فلماذا نحتاج إلى إطار عمل اختبار آخر؟ لماذا لا نكتفي مثلاً بـ JUnit الراسخ والمجرَّب؟ جوابي: يمكنك ذلك بالتأكيد! لكنك ستفوّت الكثير. فـ Kotest، مثل كل أداة أخرى في هذا المقال، يستفيد إلى أقصى حد من مزايا Kotlin المدمجة، مثل صياغتها اللطيفة الموجزة ودوال الامتداد والدوال الوسيطة (infix) والكوروتينات وغيرها.
مع ذلك، لنتفحص عن قرب بعض المزايا الرئيسية في Kotest. لكن تذكّر أننا سنكتفي بملامسة السطح، إذ إن Kotest إطار عمل واسع وغني فعلاً.
Kotest معياري بتصميمه ويتألف حالياً من ثلاث وحدات رئيسية: Test Framework وAssertions Library وProperty Testing. ويمكن استخدامها معاً أو إلى جانب أطر عمل اختبار أخرى مثل JUnit أو Spock. كما يتكامل Kotest جيداً جداً مع اختبارات Spring. إليك نظرة سريعة على كل مكوّن:
- Test Framework هو لب Kotest وأساسه. يتيح لنا تعريف حالات الاختبار وتوسيعها بخطافات دورة الحياة (lifecycle hooks) وتشغيلها على منصات مدعومة كثيرة مختلفة.
- Assertions Library هي وحدة Kotest التي تقدم مجموعة شاملة فعلاً من أدوات المطابقة (matchers) لأنواع البيانات المختلفة.
- Property Testing يعني توليد كمية كبيرة من بيانات الاختبار العشوائية تلقائياً، تغطي الحالات الحدية والحالات العادية، وتشغيل الاختبار مرات كثيرة مع كل تلك البيانات المولّدة كمدخلات.
وكما قلت، Kotest إطار عمل ضخم مليء بالمزايا والطرائف، ولا يتسع هذا المقال لها كلها، لذا إليك بعضها فقط مما قد يكون الأكثر إثارة:
- أنماط الاختبار – توفر أطر اختبار كثيرة طريقة واحدة محددة لتعريف حالات الاختبار، لكن Kotest يذهب أبعد من ذلك بكثير. فهو يقدم ما لا يقل عن عشرة أنماط اختبار مختلفة! ليتمكن كل مطور أو فريق من اختيار الصياغة الأنسب له.
- الامتدادات – لسنا مقيّدين بخطافات دورة الحياة الجاهزة والشائعة مثل
beforeSpecأوafterTest. يتيح لنا Kotest أيضاً تنفيذ امتداداتنا وخطافاتنا المخصصة وإضافتها. - التقييم الشرطي – خيار تعطيل حالات اختبار معينة تماماً، أو تفعيلها/تعطيلها فقط في ظل شروط معينة.
- دعم الكوروتينات – يمكن تشغيل حالات الاختبار داخل كوروتينات، ويمكن التحكم في الزمن، مثلاً بالتظاهر داخل حالة اختبار بأن بعض الوقت قد مضى.
- الاختبار القائم على البيانات – تنفيذ حالة الاختبار نفسها بمجموعات بيانات مختلفة، ويُعرف أيضاً بالاختبار المُعمَّم بالمعاملات (parametrized testing).
- أدوات المطابقة المخصصة – إذا كانت المكتبة القياسية ما زالت تفتقر إلى بعض أدوات المطابقة التي تحتاجها، يمكنك كتابة أدواتك الخاصة. وتذكّر أن دوال الامتداد في Kotlin والدوال الوسيطة (infix) متاحة بالكامل لذلك!
- التأكيدات الناعمة – مفيدة حين لا تريد أن يفشل الاختبار فوراً، بل أن تُنفَّذ التأكيدات الأخرى أيضاً قبل الإبلاغ عن الفشل.
- الاختبار غير الحتمي – كما يوحي الاسم، مجموعة من الأدوات والمرافق لاختبار سلوك قد يكون غير حتمي، مثل انتظار حدوث شيء ما وإعادة المحاولة وهكذا.
- المولّدات المخصصة للاختبارات القائمة على الخصائص – إذا لم تكن مجموعة المولّدات الجاهزة كافية، أو أردت مولّداً لأصنافك الخاصة، فإن المولّدات المخصصة في Kotest تتيح لك ذلك.
- التقليص (Shrinking) – استراتيجية خاصة بالاختبار القائم على الخصائص تبسّط الحالات الفاشلة للوصول إلى أصغر حالة يمكن إعادة إنتاجها. ويتولى Kotest كل ذلك نيابةً عنك.
الكلام رخيص، أرني الشيفرة! لذا إليك مقطعاً صغيراً يوضح قدرات Kotest باختصار:
class MyFunSpec: FunSpec({
test("basic Kotest features and matchers") { // test case definition in Fun Spec style
(2 + 2) shouldBe 4 // basic, universal matcher
"text" shouldContain "x" // string-specific matcher
"{\"someProp\":\"value\"}" shouldContainJsonKey "someProp" // json matcher
val numbers = listOf(2, 4, 6, 8, 10)
numbers.forAll { it.shouldBeEven() }
numbers.forExactly(2) { it shouldBeGreaterThan 7 } // sample collection inspectors
}
test("test fibonacci for n > 1 using forAll") {
forAll(Arb.int(2..10)) { n -> // property-based test using forAll with Arbitrary generator
fibonacci(n) == fibonacci(n - 1) + fibonacci(n - 2)
}
}
test("test fibonacci for n > 1 using checkAll") {
checkAll(Exhaustive.ints(2..10)) { n -> // property-based test using checkAll with Exhaustive generator
fibonacci(n) shouldBe fibonacci(n - 1) + fibonacci(n - 2)
}
}
})
class MyBehaviorSpec: BehaviorSpec({
given("Number 2") { // test case definition in Behavior Spec style
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 إطار عمل اختبار شامل ومتعمق ومليء بمزايا رائعة. أشجعك على تجربته بنفسك!
MockK – مكتبة Kotlin لمحاكاة الاعتمادات في اختبارات الوحدة
لنبقَ مع الاختبار قليلاً بعد. هذه المرة سأقدم مكتبة تتكامل مع Kotest وتوسّعه بشكل كبير، لكنها تعمل جيداً أيضاً مع أي إطار اختبار آخر. اسمح لي أن أعرّفك باختصار بـ MockK – مكتبة لمحاكاة الاعتمادات (mocking) في اختبارات الوحدة.
في الواقع، تغطي MockK معظم ما تتوقعه وتعرفه من مكتبات المحاكاة الأخرى مثل Mockito أو Spock – كالمحاكاة الجزئية والجواسيس (spies) والتحقق من التفاعلات ومطابقات المعاملات والتقاط المعاملات. لذلك لن أشرح كلاً منها بالتفصيل.
بدلاً من ذلك، إليك مثالاً مجمّعاً لحالات الاستخدام البسيطة هذه في الشيفرة:
test("basic transfer money test with mockk") {
val bankAccountMock = mockk<BankAccount>() // basic mock
every { bankAccountMock.transferMoneyTo(any()) } returnsMany listOf(0.0, 10.0, 20.0) // subsequent calls will return different results
every { bankAccountMock.transferMoneyTo(any()) } returns 0.0 andThen 10.0 andThen 20.0 // same as above
every { bankAccountMock.transferMoneyTo(more(1000.0)) } throws IllegalArgumentException("Too much money!") // argument matcher
val actualBankAccount = BankAccount()
val bankAccountSpy = spyk(actualBankAccount) // a spy
val transferMoneySlot = slot<Double>()
every { bankAccountSpy.transferMoneyFrom(capture(transferMoneySlot)) } returns 100.0 // capturing arguments
MoneyTransfer().transfer(20.0, bankAccountSpy, bankAccountMock)
val unusedBankAccountMock = mockk<BankAccount>()
verify { // interactions verification
bankAccountMock.transferMoneyTo(20.0)
bankAccountSpy.transferMoneyFrom(20.0)
unusedBankAccountMock wasNot Called
}
transferMoneySlot.captured shouldBe 20.0 // verifying the captured argument
}
والآن بعد أن أصبح لديك تصور عن أساسيات MockK، أود الإشارة إلى بعض مزاياه البارزة التي تميّزه عن مكتبات المحاكاة غير الخاصة بـ Kotlin:
- محاكاة الكائنات – إذا كنت تعرف
objectsفي Kotlin، فأنت تعلم أنها تتصرف مثل singleton، بنسخة واحدة فقط في التطبيق كله. يمكن لـ MockK محاكاة الكائنات وتجاوز التنفيذ الحقيقي لدوالها. - المحاكاة الهرمية – يستفيد MockK استفادة كاملة من صياغة Kotlin الموجزة ليقدم محاكاة هرمية، تتيح لك محاكاة الأصناف وخصائصها المتداخلة بسهولة ووضوح.
- الكوروتينات – كما تتوقع من مكتبة Kotlin أصيلة، يدعم MockK محاكاة دوال suspend مباشرة دون إعداد إضافي.
- محاكاة الدوال ذات المستوى الأعلى – ميزة أخرى في MockK تراعي صياغة Kotlin الخاصة هي القدرة على محاكاة الدوال ذات المستوى الأعلى (top-level functions).
- محاكاة دوال الامتداد – تماماً مثل الدوال ذات المستوى الأعلى، يمكن محاكاة دوال الامتداد باستخدام MockK أيضاً.
تستحق هذه المزايا الاستكشاف المعمق، وتستحق MockK عموماً التجربة، سواء مع Kotest أو مع أي إطار اختبار آخر تفضله.
Konform – مكتبة التحقق من الصحة في Kotlin
التحقق من صحة البيانات جزء أساسي من أي منطق عمل في تطبيقاتنا. يجب التحقق من بيانات الإدخال حتى يمكن معالجتها أو تخزينها بموثوقية وأمان.
والمكتبة التالية التي سأقدمها تدور حول ذلك تماماً.
Konform هي مكتبة للتحقق من الصحة في Kotlin بمجموعة مزايا غنية إلى حد ما وDSL موجز ومريح جداً. ورغم أن Konform يخدم غرضاً واحداً – التحقق من بياناتك – فإنه يقدم عدداً مفاجئاً من الاختلافات الصغيرة وحالات الاستخدام لمواقف مختلفة. وهي جميعاً موثقة بوضوح على موقع Konform، لذلك بدلاً من مناقشة كل منها وتكرار كل ذلك المحتوى هنا، سأعطيك لمحة سريعة عما تستطيع المكتبة فعله، لتعرف ما تتوقعه.
لنفترض أن تطبيقنا يحتوي على النموذج التالي:
data class Order(
val id: String,
val lines: List<OrderLine>,
val invoiceId: String?
)
data class OrderLine(
val id: String,
val product: Product
)
data class Product(
val name: String,
val price: Double
)
لهذه الأصناف يمكننا تعريف مدققات الصحة (validators) التالية:
val validateOrder = Validation<Order> { // validator for Order class
Order::id { // validator for specific field
minLength(3)
maxLength(128) hint "'{value}' is too long, must be between 3 and 128" // optional hint for the validation
}
Order::invoiceId ifPresent { // validation for optional field
pattern("INV-\\d{5}")
}
Order::lines { // collection validation
maxItems(100) hint "order can have at most 100 lines"
}
Order::lines onEach { // collection items validation
run(validateOrderLine) // delegating validation to external validator
}
}
val validateOrderLine = Validation<OrderLine> { // external validator for OrderLine
OrderLine::id {
constrain("line ID cannot contain whitespaces") { !it.contains("\\s") } // custom validation
}
OrderLine::product {
Product::price dynamic { product -> // dynamic validation
if (product.name.startsWith("Business ")) minimum(10_000.0)
else minimum(0.0)
}
}
}
بعد ذلك تصبح المدققات جاهزة للاستخدام:
val invalidOrder = Order(
id = "ID",
lines = listOf(
OrderLine(
id = "line_id 123",
product = Product(
name = "Business Super Product",
price = 500.0
)
)
),
invoiceId = "INV-abc"
)
val orderValidationResult = validateOrder(invalidOrder)
println(orderValidationResult)
ونتيجة لذلك، يحتوي orderValidationResult على معلومات حول ما إذا كان الكائن صالحاً، إضافةً إلى أي إخفاقات في التحقق. لاحظ أن Konform ينفّذ افتراضياً التحقق الكامل بصرف النظر عن مصادفته حقولاً غير صالحة في وقت مبكر. لكن يمكن عند الحاجة إعداده صراحةً ليفشل بسرعة.
إجمالاً، يبدو Konform مكتبة تحقق واعدة جداً لمشاريع Kotlin. وهناك أمر آخر قد ترغب في معرفته – وقت كتابة هذا المقال، أحدث إصدار من Konform هو 0.10.0، وله «فقط» 700 نجمة على GitHub. لكن، لا بأس، فلا بد للجميع من بداية!
Detekt – محلل شيفرة ساكن لـ Kotlin
العنصر الأخير في هذا المقال مختلف عن كل ما وصفته حتى الآن. فحتى الآن قدمت أطر عمل أو مكتبات إما توفر مزايا محددة لتطبيقك أو ترفع إنتاجيتك في مجالات متنوعة. أما هذه المرة، فسأقدم أداة تساعدك على إبقاء جودة قاعدة شيفرتك عالية قدر الإمكان.
Detekt هو محلل شيفرة ساكن (static code analyser) لـ Kotlin. إذا كانت خلفيتك في Java، فربما تفكر الآن في Sonar. وهذا هو الأمر في جوهره – فـ Detekt يعمل بطريقة قريبة جداً منه، لكنه مبني بالكامل لـ Kotlin. أبرز مزايا Detekt:
- تحليل مواطن الخلل في الشيفرة (code smells)،
- توليد التقارير بصيغ عدة، منها HTML وMarkdown وSARIF وXML،
- التكامل مع مجموعة من أدوات البناء، منها CLI وMaven وGradle،
- قابلية التوسّع – يمكن إعداده بمجموعات قواعد خارجية ومنسّقات شيفرة وتقارير مخصصة.
لنرَ كيف تضيف Detekt إلى مشروعك. إذا كان لديك مشروع Gradle، فكل ما عليك هو إضافة الإضافة التالية إلى ملف البناء:
plugins {
id("io.gitlab.arturbosch.detekt") version "1.23.7"
}
هذا كل شيء! Detekt يؤدي عمله بالفعل بالإعداد الافتراضي. وبالطبع هناك طرق كثيرة لإعداد Detekt بشكل إضافي ليناسب احتياجاتك بدقة. ويتم ذلك داخل الكتلة detekt:
detekt {
buildUponDefaultConfig = true
allRules = false
config.setFrom("$projectDir/config/detekt.yml")
baseline = file("$projectDir/config/baseline.xml")
}
هذه مجرد حفنة من الإعدادات النموذجية. ويمكن العثور على القائمة الكاملة لخيارات الإعداد في صفحة وثائق Detekt المخصصة.
وإذا أردت تخصيص تقارير Detekt لعمليات البناء لديك، فهذا مدعوم مباشرة أيضاً:
tasks.withType<Detekt>().configureEach {
reports {
html.required.set(true)
html.outputLocation.set(file("build/reports/detekt.html"))
xml.required.set(true)
sarif.required.set(true)
md.required.set(true)
custom {
reportId = "CustomJsonReport"
outputLocation.set(file("build/reports/detekt.json"))
}
}
}
وجميع خيارات تخصيص التقارير المتاحة مدرجة كذلك في قسم التقارير من وثائق Detekt الرسمية.
ولتشغيل تحليل الشيفرة، يكفي استدعاء مهمة Gradle هذه:
gradle detekt
كما أن Detekt مرتبط تلقائياً بمهمة البناء في Gradle، لذا يعمل التحليل أيضاً عند استدعاء:
gradle build
باختصار، إذا كنت بحاجة إلى أداة شاملة تضمن أن تبقى قاعدة شيفرة Kotlin لديك دائماً بأعلى جودة، فإن Detekt مناسب لك بالتأكيد.
الخلاصة
وهذا كل شيء. في هذا المقال حاولت أن أستعرض معك قائمة بأدوات رائعة ينبغي أن تكفي لإطلاق تطبيق Kotlin من جهة الخادم من أي نوع، سواء كان خدمة مصغّرة بواجهة REST API أو تطبيق سطر أوامر أو دالة بدون خادم (serverless) مثل AWS Lambda. وكل منها يستفيد استفادة كاملة من لغة Kotlin وجميع مزاياها، مما يضمن التوافق التام بين جميع مكونات نظامك.
آمل أن يكون في هذا المقال ما أثار اهتمامك، وأن يتبين أن بعض أطر عمل ومكتبات Kotlin التي وصفتها باختصار مفيدة لك. لا تتردد في التعمق في الوثائق والأدلة وتجربتها بنفسك واختيار ما تراه الأكثر فائدة وإعطائها فرصة، ومن يدري – ربما تغيّر قواعد اللعبة في مشروعك القادم؟