Backend մշակման համար Kotlin-ի 7 գրադարան և ֆրեյմվորք, որոնք արժե իմանալ
Բացահայտեք Kotlin-ի բնիկ գրադարաններն ու ֆրեյմվորքները, որոնք ամբողջությամբ գրված են այս լեզվով և ստեղծված հենց դրա համար։
Կարող եմ նույնիսկ ասել, որ այսօր ժամանակակից ծրագրավորման լեզուն, որը չունի գրադարանների և ֆրեյմվորքների հարուստ էկոհամակարգ, ուշ թե շուտ կդառնա պարզապես նրբագեղ խաղալիք՝ առանց իրական կիրառության։
Բարեբախտաբար, Kotlin-ը այդ վիճակից շատ հեռու է։ Ինչո՞ւ։ Նախ՝ Java-ի հետ Kotlin-ի գերազանց ինտեգրման շնորհիվ՝ Java-ի ողջ էկոհամակարգը կարելի է առանց դժվարության օգտագործել Kotlin-ից։ Երկրորդ՝ Kotlin-ի բնիկ գրադարանների և ֆրեյմվորքների արդեն մեծ քանակի շնորհիվ, որոնք ամբողջությամբ գրված են այս լեզվով և ստեղծված հենց դրա համար։
Լավ, ուրեմն կարդում եք այս բլոգ գրառումը։ Գուցե դուք backend Java ծրագրավորող եք, որը նոր է որոշել հաջորդ նախագծում փորձել Kotlin-ը։ Կամ գուցե Kotlin-ով mobile ծրագրավորող եք, որն արդեն գիտի Kotlin-ը և ուզում է անցնել backend մշակման՝ առանց հրաժարվելու իր սիրելի լեզվից։ Ինչպես էլ լինի, գուցե հարցնում եք. վերը նշվածներից կա՞ն Kotlin-ի բնիկ գրադարաններ և ֆրեյմվորքներ, որոնք թույլ կտան բացահայտել Kotlin-ի ողջ ներուժը backend-ում։
Կարճ պատասխանը՝ այո։
Ավելի երկար պատասխանը՝ այո, անշուշտ։
Եկեք միասին ուսումնասիրենք Kotlin-ի լավագույն գրադարաններից և ֆրեյմվորքներից մի քանիսը, որոնք կօգնեն արդյունավետ կերպով ստեղծել արտադրական, ձեռնարկության մակարդակի backend հավելվածներ Kotlin-ի ոճով։
Ktor – Kotlin ֆրեյմվորք վեբ հավելվածներ ստեղծելու համար
Ինչ տեսել եմ՝ «backend մշակում» ասելով սովորաբար նկատի են ունենում վեբ հավելվածներ կամ միկրոսերվիսներ։ Ուստի backend մշակումը աջակցելու համար ծրագրավորման լեզուն պետք է ունենա մի քանի համապարփակ վեբ ֆրեյմվորք։ Kotlin-ը բացառություն չէ։
Եթե Java-ի փորձ ունեք, Spring Boot-ը հավանաբար առաջին վեբ ֆրեյմվորքն է, որ միտքդ է գալիս։ Այդ ժամանակ կարող եք հարցնել. կարո՞ղ եմ պարզապես Kotlin հավելվածներ գրել Spring Boot-ով։ Հանգիստ եղեք՝ իհարկե կարող եք, և դա բավականին տարածված պրակտիկա է. Spring Boot-ը Kotlin-ի հետ շատ լավ է աշխատում։ Բայց եթե ուզում եք ավելի առաջ գնալ և հաջորդ server-side հավելվածը ստեղծելիս լիարժեք օգտագործել Kotlin-ը, Ktor ֆրեյմվորքը կարող է հենց այն լինել, ինչ պետք է։
Ktor-ը վեբ հավելվածներ ստեղծելու ֆրեյմվորք է, որը ստեղծել է JetBrains-ը՝ հենց այն մարդիկ, որոնք ծնունդ տվեցին Kotlin-ին։ Միայն դա արդեն ազդանշան է, որ ֆրեյմվորքն ու լեզուն նախագծված են համագործակցելու և իրար հնարավորությունները լրացնելու համար։ Դա ակնհայտ է դառնում, երբ սկսում ենք Ktor-ով կոդ գրել. կորուտիններ, extension ֆունկցիաներ, trailing լամբդաներ. Kotlin-ի այս բոլոր հնարավորությունները առաջին կարգի քաղաքացիներ են և Ktor-ի հիմքերը։
Ktor-ը նաև ձգտում է լինել հնարավորինս թեթև և պարզ։ Այն կառուցված է ասինխրոնությունը նկատի ունենալով և կարող է աշխատել ցանկացած servlet կոնտեյներում, որն աջակցում է Servlet 3.0+ API-ն, ինչպես Tomcat-ը, կամ ինքնուրույն՝ Netty-ով կամ Jetty-ով։ Նայեք ստորև բերված հատվածին, որը ցույց է տալիս նվազագույն Ktor հավելված, որը սպասարկում է REST endpoint։
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-ը շատ ավելին կարող է։ Սա մոդուլային ֆրեյմվորք է, որի փիլիսոփայությունն է Kotlin ծրագրավորողներին թույլ տալ ընտրել հենց այն, ինչ իրենց հավելվածին պետք է, և ոչ ավելին։ Համապատասխանաբար, Ktor-ը տրամադրում է բազմաթիվ plugin-ներ, որոնք կարելի է ավելացնել նախագծին կամ դրա ստեղծման պահին, կամ ավելի ուշ՝ որպես Gradle plugin-ներ և կախվածություններ։ Հասանելի plugin-ների կատալոգն արդեն լայն է և ընդգրկում է այնպիսի կատեգորիաներ, ինչպիսիք են անվտանգությունը, HTTP-ն, մոնիթորինգը, տվյալների բազաները և շատ ուրիշներ։
Դրանից բացի, Ktor-ն ունի շատ այլ հնարավորություններ, որոնք սպասում եք հասուն վեբ ֆրեյմվորքից, այդ թվում՝
- property-ների վրա հիմնված կոնֆիգուրացիա
- HTTP/2 աջակցություն (նաև SSL սերտիֆիկատներով)
- Content-negotiation և սերիալիզացիա
- Web sockets
- Templating գրադարանների մի շարք
- HTTP սեսիաներ
Ինչպես Spring Boot-ը, Ktor-ն էլ ունի հարմար նախագծի գեներատոր։ Այն թույլ է տալիս արագ կարգավորել և գեներացնել նախագծի սկզբնական կառուցվածքը՝ պահանջվող կախվածություններով, կոնֆիգուրացիայի ֆայլերով և օրինակելի կոդով։ Գեներատորը կարող եք օգտագործել կամ բրաուզերում, կամ ուղղակի IntelliJ IDEA-ից։
Ktor-ը, անշուշտ, արժանի է առանձին բլոգ գրառման, և մենք հենց հիմա աշխատում ենք այդ ուղղությամբ մի բանի վրա, ուստի հետևեք մեզ։
Koin – Kotlin-ի թեթև dependency injection ֆրեյմվորք
Եթե ծրագրային ապահովման մշակմանը միացել եք ոչ երեկ, անշուշտ հանդիպել եք Dependency Injection (DI)-ի։ Այս հասկացությունը, որը թույլ կապված է Uncle Bob Martin-ի հայտնի SOLID-ի Dependency Inversion սկզբունքի հետ, ընդունվել և իրականացվել է բազմաթիվ գրադարանների և ֆրեյմվորքների կողմից և այժմ լայնորեն օգտագործվում է ողջ ոլորտում։ Բավական է ասել, որ Spring-ն ինքը սկսվել է որպես dependency injection կոնտեյներ, մինչև վերջում դարձավ այնքան մեծ և բազմակողմանի ֆրեյմվորք, որ գործնականում իր սեփական ֆրեյմվորքն էր պետք (այո, Spring Boot, քեզ նկատի ունեմ)։ Ուստի զարմանալի չէ, որ Kotlin-ը այս ոլորտում ևս պատասխան ունի։ Ծանոթացեք՝ Koin – Kotlin-ի թեթև dependency injection ֆրեյմվորք։
Ինչպես այստեղ քննարկվող յուրաքանչյուր գրադարան և ֆրեյմվորք, Koin-ը ամբողջությամբ գրված է Kotlin-ով։ Ուստի դրա վաճառքի կետերից և ուժեղ կողմերից մեկը շատ հակիրճ, Kotlin ոճի շարահյուսությունն է, որը լայնորեն օգտագործում է կոդ գրելու DSL-նման մոտեցում։
Koin-ի մեկ այլ հիանալի կողմն այն է, որ այն ի սկզբանե բազմապլատֆորմ է։ Այն կարելի է օգտագործել server-side հավելվածներում՝ լինի սովորական Kotlin, թե Ktor, ինչպես նաև client-side հավելվածներում՝ բնիկ Android, Jetpack Compose կամ mobile multiplatform հավելվածներ։ Koin-ի պաշտոնական փաստաթղթերը նույնիսկ բացահայտ նկարագրում են այս օգտագործման դեպքերը։
Եկեք դիտարկենք Koin-ի ամենահիմնական օգտագործումը սովորական backend հավելվածում՝ 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()
}
Այստեղ մի քանի հիմնական փուլ կա։
- Հայտարարում ենք ինտերֆեյս, որը կծառայի որպես մեր կախվածության պայմանագիր։ Նկատեք, որ այս քայլը պարտադիր չէ. իրական իրականացումները կարելի է ներարկել որպես կախվածություններ ուղղակիորեն, առանց միջանկյալ ինտերֆեյսների։
- Հետո տալիս ենք այդ ինտերֆեյսի կոնկրետ իրականացումը։
- Այստեղ Koin-ը առաջին անգամ մտնում է պատկերի մեջ. մոդուլ սահմանելով՝ կոնկրետ իրականացումները կապում ենք մեր բոլոր կախվածություններին։ Այս դեպքում նշում ենք, որ
GreetingServiceինտերֆեյսը կլինի singleton, որը ապահովվում էGreetingServiceImplդասով։ Բացի singleton-ներից՝ կարելի է սահմանել նաև factory-ներ։ Նաև արժե նշել, որ Koin-ը թույլ է տալիս սահմանել մի քանի մոդուլ՝ կախվածությունների տարբեր հավաքածուներով։ - Koin-ի կառավարած կախվածությունները ներարկելու համար պետք է
KoinComponent-ը ընդլայնող դաս։ Այստեղ դաGreetingsApplication-ն է, բայց դա կարող է լինել հավելվածի ցանկացած մուտքի կետի դաս, օրինակ՝ REST կոնտրոլեր կամ JMS իրադարձության լսող։ - Այսպես է իրականում Koin-ում գործարկվում dependency injection-ը։
KoinComponent-ի ներսում ցանկացած Koin մոդուլում սահմանված ցանկացած կախվածություն կարելի է ներարկել by inject() delegate ֆունկցիայով։ - Վերջապես, որպեսզի ամեն ինչ աշխատի, Koin կոնտեյները պետք է գործարկել հիմնական մուտքի կետում։
startCoinֆունկցիան ընդունում է բոլոր մոդուլները, որոնք ուզում ենք ներառել հավելվածում, և թույլ է տալիս այն լրացուցիչ կարգավորել, օրինակ՝ նշելով logger կամ արտաքին property-ներ։
Եթե annotation-ների «կախարդանքը» ձեր սիրածն է, Koin-ը դա էլ ունի։ Վերևի նույն արդյունքը կարելի է ստանալ annotation-ներով.
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 annotation-ը։ Սա annotation-ների վրա հիմնված եղանակն է ասելու, որ այս դասը կլինի singleton կախվածություն, կապվածGreetingServiceինտերֆեյսի հետ։ - Այս քայլում սահմանում ենք մոդուլի դաս։ Այն ծառայում է որպես նշիչ, որը Koin-ին ասում է մոդուլի scope-ը և որտեղ փնտրել մոդուլին պատկանող բաղադրիչները (այսինքն՝ annotation-ներով դասերը)։
- Կախվածությունները կարելի է ներարկել
KoinComponent-ի մեջ։ Սա նույնն է, ինչ annotation-ներ չունեցող օրինակում։ - Annotation-ները փոխում են միայն այն, թե ինչպես են սահմանվում կախվածությունները, ոչ թե ինչպես են ներարկվում, ուստի այս տողը համընկնում է Koin API-ի DSL տարբերակի հետ։
- Կրկին գործարկում ենք Koin կոնտեյները մոդուլներով։ Սակայն նկատեք, թե որքան այլ կերպ են մոդուլները փոխանցվում նախորդ օրինակի համեմատ։ Այս անգամ դիմում ենք 3-րդ քայլում սահմանված
GreetingsModuleդասիmoduleհատկությանը։ Նկատեք, որ դասը ո՛չ նման հատկություն է հայտարարում, ո՛չ որևէ բան ընդլայնում։ Հենց այստեղ է գործի անցնում annotation-ների կախարդանքը. Koin-ը հենվում է KSP (Kotlin Symbol Processing) plugin-ի վրա, որը կարդում է Koin-ի annotation-ները և կոմպիլյացիայի ժամանակ գեներացնում է անհրաժեշտ մեթոդներն ու հատկությունները։
Սրանք են Koin-ի հիմունքները։ Հիշեցնեմ՝ ինչպես նախկինում ասացի, Koin-ը լիովին համատեղելի է Ktor ֆրեյմվորքի հետ, ուստի երկուսը կարելի է անխափան համադրել՝ վեբ հավելվածներն ավելի արդյունավետ ստեղծելու համար։
Exposed – թեթև SQL և ORM persistence ֆրեյմվորք
Դժվար է պատկերացնել ՏՏ համակարգ առանց persistence-ի։ Ուշ թե շուտ ձեր backend հավելվածը ստիպված կլինի ինչ-որ տվյալներ պահել։ Քանի որ ռելացիոն տվյալների բազաները շարունակում են մնալ այսօրվա ամենատարածված տվյալների բազաները, Kotlin-ով աշխատելիս հավանաբար կուզենաք ձեռքի տակ ունենալ հուսալի SQL-ի վրա հիմնված persistence ֆրեյմվորք։ Բարեբախտաբար, կա մեկը, որը կատարյալ կերպով համապատասխանում է. Exposed։
Exposed-ը Kotlin-ով գրված թեթև SQL և ORM persistence ֆրեյմվորք է։ Ինչպես Ktor-ը, այն էլ պահպանվում է JetBrains-ի կողմից. հիշեցնեմ՝ այն ընկերությունը, որը կանգնած է հենց Kotlin լեզվի հետևում։
Exposed-ը աշխատում է Kotlin JDBC դրայվերի վրա և, գրելու պահին, աջակցում է հետևյալ տվյալների բազաները՝ H2, MariaDB, MySQL, Oracle, PostgreSQL, Microsoft SQL Server, SQLite։ Տվյալների բազայի կապը կարգավորելու համար բավական է սա.
Database.connect("jdbc:h2:mem:test", driver = "org.h2.Driver")
Առաջին պարամետրը կապի URL-ն է, իսկ երկրորդը՝ տվյալների բազայի դրայվերը։ Սա, իհարկե, տվյալների բազայի կապը կարգավորելու միայն մեկ եղանակն է, և ամենապարզը։ Կան նաև Database.connect()-ի ավելի բարդ կանչեր, որոնք ավելի շատ պարամետրեր են ընդունում։ Ավելին, տվյալների բազայի կապը կարելի է կարգավորել՝ Database.connect()-ին փոխանցելով javax.sql.DataSource օրինակ, ինչը հասանելի է դարձնում DataSource-ի առաջարկած տվյալների բազայի կապի բոլոր առաջադեմ կարգավորման հնարավորությունները, օրինակ՝ կապերի 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-ով և entity-ներով։ Ստորև բերված են մի քանի նվազագույն կոդի հատվածներ, որպեսզի պատկերացում կազմեք, թե ինչպիսին են տվյալների բազայի հասանելիության այս երկու ոճերը 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 entity դասը.
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
}
Entity-ն ունենալով՝ կարող ենք դրա վրա կատարել տարբեր գործողություններ.
// 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 ֆրեյմվորքի կողմից և առաջարկվում է որպես նրա plugin-ներից մեկը։
Ուզո՞ւմ եք Exposed ֆրեյմվորքի մասին ավելին իմանալ։ Հետևեք մեր առաջիկա բլոգ գրառումներին Exposed-ի մասին։
Kotest – Kotlin-ի թեստավորման ֆրեյմվորք
Չեմ կարծում, որ չափազանցություն է ասել, որ այսօր դժվար է պատկերացնել ծրագրային ապահովում առանց թեստերի (եթե դա չէ ինչ-որ PoC կամ նախատիպ)։ Ուստի հուսալի, հարմար թեստավորման ֆրեյմվորքը կարևոր է ծրագրավորման յուրաքանչյուր լեզվի համար։ Kotlin-ը ունի՞ այդպիսին։
Տիկնայք և պարոնայք, ողջունեք Kotest-ը։
Նախքան Kotest-ի հնարավորությունների մեջ խորանալը, թույլ տվեք մի պահ կանգ առնել և անդրադառնալ մի հարցի կամ կասկածի, որը հենց նոր կարող էր միտքդ անցնել. եթե Kotlin-ը Java-ի հետ այդքան լավ է աշխատում, ինչո՞ւ է մեզ ևս մեկ թեստավորման ֆրեյմվորք պետք։ Ինչո՞ւ չմնալ, ասենք, լավ հաստատված, փորձված JUnit-ի հետ։ Իմ պատասխանը. իհարկե կարող եք։ Բայց շատ բան բաց կթողնեք։ Kotest-ը, ինչպես այս հոդվածի յուրաքանչյուր գործիք, առավելագույնս օգտագործում է Kotlin-ի ներկառուցված հնարավորությունները, ինչպիսիք են հաճելի, հակիրճ շարահյուսությունը, extension ֆունկցիաները, infix մեթոդները, կորուտինները և այլն։
Այս ամենով հանդերձ, եկեք ավելի մոտիկից քննենք Kotest-ի հիմնական հնարավորություններից մի քանիսը։ Սակայն հիշեք, որ մենք միայն մակերեսին կանդրադառնանք, քանի որ Kotest-ը իսկապես լայն և հարուստ ֆրեյմվորք է։
Kotest-ը ի սկզբանե մոդուլային է և ներկայումս բաղկացած է երեք հիմնական մոդուլից՝ Test Framework, Assertions Library և Property Testing։ Դրանք կարելի է օգտագործել միասին կամ այլ թեստավորման ֆրեյմվորքների հետ, ինչպիսիք են JUnit-ը կամ Spock-ը։ Kotest-ը նաև շատ լավ զուգակցվում է Spring թեստերի հետ։ Ահա յուրաքանչյուր բաղադրիչի կարճ ակնարկը։
- Test Framework-ը Kotest-ի միջուկն ու հիմքն է։ Այն թույլ է տալիս սահմանել թեստային դեպքեր, ընդլայնել դրանք lifecycle hook-երով և գործարկել բազմաթիվ աջակցվող պլատֆորմների վրա։
- Assertions Library-ն Kotest-ի մոդուլն է, որն առաջարկում է matcher-ների իսկապես համապարփակ հավաքածու տվյալների տարբեր տիպերի համար։
- Property Testing-ը վերաբերում է մեծ քանակությամբ պատահական թեստային տվյալների ավտոմատ գեներացմանը՝ ընդգրկելով և եզրային, և սովորական դեպքերը, և թեստը շատ անգամ գործարկելուն՝ այդ բոլոր գեներացված տվյալներով որպես մուտք։
Ինչպես ասացի, Kotest-ը հնարավորություններով և հետաքրքիր առանձնահատկություններով լի հսկայական ֆրեյմվորք է, և այս հոդվածում բոլորի համար տեղ չկա, ուստի ահա միայն մի քանիսը, որոնք կարող են ամենահետաքրքիրը լինել։
- Թեստավորման ոճեր – թեստավորման շատ ֆրեյմվորքներ թեստային դեպքեր սահմանելու մեկ, կոնկրետ եղանակ են տալիս, բայց Kotest-ը շատ ավելի առաջ է գնում։ Այն առաջարկում է տասը տարբեր թեստավորման ոճ։ Այսպիսով յուրաքանչյուր ծրագրավորող կամ թիմ կարող է ընտրել իրեն ամենահարմար շարահյուսությունը։
- Extension-ներ – մենք սահմանափակված չենք նախասահմանված, տարածված lifecycle hook-երով, ինչպիսիք են
beforeSpec-ը կամafterTest-ը։ Kotest-ը թույլ է տալիս նաև իրականացնել և միացնել մեր սեփական extension-ներն ու hook-երը։ - Պայմանական գնահատում – որոշակի թեստային դեպքերը լիովին անջատելու կամ դրանք միայն որոշակի պայմաններում միացնելու/անջատելու հնարավորություն։
- Կորուտինների աջակցություն – թեստային դեպքերը կարող են աշխատել կորուտինների ներսում, և ժամանակը կարելի է կառավարել, օրինակ՝ թեստային դեպքի ներսում ձևացնելով, թե ինչ-որ ժամանակ անցել է։
- Տվյալներով ղեկավարվող թեստավորում – նույն թեստային դեպքի կատարում տվյալների տարբեր հավաքածուներով, որը հայտնի է նաև որպես պարամետրացված թեստավորում։
- Սեփական matcher-ներ – եթե ստանդարտ գրադարանում դեռ պակասում են ձեզ անհրաժեշտ որոշ matcher-ներ, կարող եք գրել ձերը։ Հիշեք, որ Kotlin-ի extension ֆունկցիաներն ու infix մեթոդները դրա համար լիովին հասանելի են։
- Soft assertion-ներ – հարմար են, երբ չեք ուզում, որ թեստը արագ ձախողվի, այլ որ ձախողումը հայտնելուց առաջ կատարվեն նաև մյուս assertion-ները։
- Ոչ դետերմինիստական թեստավորում – ինչպես անունն է հուշում, գործիքների և օժանդակ միջոցների հավաքածու՝ պոտենցիալ ոչ դետերմինիստական վարքագիծը թեստավորելու համար, օրինակ՝ ինչ-որ բանի տեղի ունենալուն սպասելը, կրկնելը և այլն։
- Property-վրա հիմնված թեստերի համար սեփական գեներատորներ – եթե նախասահմանված գեներատորների հավաքածուն բավարար չէ, կամ ուզում եք գեներատոր ձեր սեփական դասերի համար, Kotest-ի սեփական գեներատորները թույլ են տալիս դա անել։
- Shrinking – property-վրա հիմնված թեստավորման հատուկ ռազմավարություն, որը պարզեցնում է ձախողվող դեպքերը՝ ամենափոքր վերարտադրելի դեպքին հասնելու համար։ 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-ի գրադարան unit թեստերում կախվածությունները mock անելու համար
Եկեք թեստավորման թեմայում մնանք մի փոքր ավելի երկար։ Այս անգամ կներկայացնեմ գրադարան, որը ինտեգրվում է Kotest-ի հետ և զգալիորեն ընդլայնում այն, բայց նույնքան լավ աշխատում է ցանկացած այլ թեստավորման ֆրեյմվորքի հետ։ Թույլ տվեք կարճ ներկայացնել MockK-ը՝ unit թեստերում կախվածությունները mock անելու գրադարան։
Իրականում MockK-ը ընդգրկում է այն ամենը, ինչ կսպասեք և գիտեք այլ mocking գրադարաններից, ինչպիսիք են Mockito-ն կամ Spock-ը. օրինակ՝ մասնակի mock-եր, spy-եր, փոխազդեցությունների ստուգում, արգումենտների matcher-ներ և արգումենտների գրավում։ Ուստի դրանցից յուրաքանչյուրը մանրամասն չեմ քննարկի։
Փոխարենը՝ ահա այս պարզ օգտագործման դեպքերի համակցված օրինակ կոդով.
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 mocking գրադարաններից։
- Օբյեկտների mock-եր – եթե գիտեք Kotlin-ի
objects-ը, գիտեք, որ դրանք վարվում են ինչպես singleton-ներ՝ հավելվածում ընդամենը մեկ օրինակով։ MockK-ը կարող է mock անել օբյեկտները՝ վերասահմանելով դրանց մեթոդների իրական իրականացումը։ - Հիերարխիկ mock անելը – MockK-ը լիովին օգտագործում է Kotlin-ի հակիրճ շարահյուսությունը՝ առաջարկելու հիերարխիկ mock-եր, որոնք թույլ են տալիս հեշտությամբ և հստակ mock անել դասերն ու դրանց ներդրված հատկությունները։
- Կորուտիններ – ինչպես սպասում եք բնիկ Kotlin գրադարանից, MockK-ը առանց լրացուցիչ կարգավորման աջակցում է suspend ֆունկցիաների mock անելը։
- Top-level ֆունկցիաների mock անելը – MockK-ի ևս մեկ հնարավորություն, որը սպասարկում է Kotlin-ի առանձնահատուկ շարահյուսությունը, top-level ֆունկցիաները mock անելու հնարավորությունն է։
- Extension ֆունկցիաների mock անելը – ճիշտ ինչպես top-level ֆունկցիաները, extension ֆունկցիաները ևս կարելի է mock անել 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
)
Այս դասերի համար կարող ենք սահմանել հետևյալ վալիդատորները.
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-ն է, և այն GitHub-ում ունի «ընդամենը» 700 աստղ։ Բայց հե՜յ, բոլորը ինչ-որ տեղից պետք է սկսեն։
Detekt – Kotlin-ի ստատիկ կոդի անալիզատոր
Այս հոդվածի վերջին կետը տարբերվում է մինչ այժմ նկարագրված ամեն ինչից։ Մինչ այժմ ներկայացրել եմ ֆրեյմվորքներ կամ գրադարաններ, որոնք կամ տալիս են ձեր հավելվածի համար որոշակի հնարավորություններ, կամ բարձրացնում են արտադրողականությունը տարբեր ոլորտներում։ Այս անգամ կներկայացնեմ գործիք, որը օգնում է ձեր կոդի բազայի որակը պահել հնարավորինս բարձր։
Detekt-ը Kotlin-ի ստատիկ կոդի անալիզատոր է։ Եթե Java-ի փորձ ունեք, հավանաբար հենց հիմա մտածում եք Sonar-ի մասին։ Եվ ըստ էության դա է. Detekt-ը շատ նման է դրան, բայց կառուցված է ամբողջությամբ Kotlin-ի համար։ Detekt-ի հիմնական հնարավորություններն են՝
- code smell-երի վերլուծություն,
- հաշվետվությունների գեներացում մի քանի ձևաչափով, այդ թվում՝ HTML, Markdown, SARIF, XML,
- ինտեգրում մի շարք build գործիքների հետ, այդ թվում՝ CLI, Maven, Gradle,
- ընդլայնելիություն. այն կարելի է կարգավորել արտաքին կանոնների հավաքածուներով, կոդի ֆորմատավորիչներով և սեփական հաշվետվություններով։
Տեսնենք, թե ինչպես ավելացնել Detekt-ը ձեր նախագծին։ Եթե ունեք Gradle նախագիծ, պետք է միայն ձեր build ֆայլին ավելացնել հետևյալ plugin-ը.
plugins {
id("io.gitlab.arturbosch.detekt") version "1.23.7"
}
Այսքանը։ Detekt-ը արդեն կատարում է իր գործը լռելյայն կոնֆիգուրացիայով։ Իհարկե, Detekt-ը լրացուցիչ կարգավորելու շատ եղանակներ կան, որպեսզի այն ճշգրիտ համապատասխանի ձեր կարիքներին։ Սա արվում է detekt closure-ի ներսում.
detekt {
buildUponDefaultConfig = true
allRules = false
config.setFrom("$projectDir/config/detekt.yml")
baseline = file("$projectDir/config/baseline.xml")
}
Սրանք կարգավորումների միայն մի բուռ օրինակներ են։ Կոնֆիգուրացիայի ընտրանքների ամբողջական ցանկը կարելի է գտնել Detekt-ի փաստաթղթերի հատուկ էջում։
Եթե ուզում եք ձեր build-երի համար հարմարեցնել 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-ի պաշտոնական փաստաթղթերի Reports բաժնում։
Կոդի վերլուծությունը գործարկելու համար պարզապես պետք է կանչել այս Gradle task-ը.
gradle detekt
Detekt-ը նաև ավտոմատ կերպով միացված է Gradle build task-ին, ուստի վերլուծությունը կատարվում է նաև, երբ կանչում եք.
gradle build
Մի խոսքով, եթե ձեզ համապարփակ գործիք է պետք՝ ապահովելու, որ ձեր Kotlin կոդի բազան միշտ մնա ամենաբարձր որակի, Detekt-ը անպայման ձեզ համար է։
Ամփոփում
Եվ վերջ։ Այս բլոգ գրառման մեջ փորձեցի ձեզ ներկայացնել հիանալի գործիքների ցանկ, որոնք պետք է բավարար լինեն ցանկացած տեսակի Kotlin server-side հավելված սկսելու համար՝ լինի դա REST API-ով միկրոսերվիս, հրամանի տողի հավելված, թե serverless ֆունկցիա, ինչպիսին AWS Lambda-ն է։ Դրանցից յուրաքանչյուրը լիարժեք օգտագործում է Kotlin լեզուն և դրա բոլոր հնարավորությունները, ինչը ապահովում է ձեր համակարգի բոլոր բաղադրիչների լիակատար համատեղելիություն։
Հուսով եմ՝ ինչ-որ բան այստեղ հետաքրքրեց ձեզ, և իմ կարճ նկարագրած Kotlin ֆրեյմվորքներից ու գրադարաններից գոնե մի քանիսը օգտակար կլինեն ձեզ։ Ազատ զգացեք խորանալ փաստաթղթերի և ուղեցույցների մեջ, ինքներդ փորձեք դրանք, ընտրեք ձեզ ամենաօգտակար թվացողները, տվեք դրանց հնարավորություն, և ո՞վ գիտի՝ գուցե դրանք կփոխեն ձեր հաջորդ նախագծի ընթացքը։