Միկրոսերվիսների թեստավորումը կոնտրակտային թեստերով
Մոնոլիտ հավելվածը թեստավորելը բավականին պարզ է, սակայն միկրոսերվիսները թեստավորումը նկատելիորեն դժվարացնում են: Բարեբախտաբար, յուրաքանչյուր խնդրի համար կա օրինաչափություն, և այստեղ դա կոնտրակտային թեստավորումն է: Տեսեք, թե ինչպես է այն հեշտացնում միկրոսերվիսների թեստավորումը։
Մոնոլիտ հավելվածը թեստավորելը բավականին պարզ է։ Մենք գրում ենք յունիթ թեստեր, ինտեգրացիոն թեստեր և, ամենայն հավանականությամբ, end-to-end թեստեր՝ փորձելով թեստավորման բուրգը պահել հնարավոր լավագույն վիճակում։ Սակայն միկրոսերվիսները թեստավորումը մի փոքր բարդացնում են։ Նրանց հիմնական առանձնահատկությունը հաղորդակցությունն է, որը միկրոսերվիսային ճարտարապետության հիմքում է։ Բարեբախտաբար, յուրաքանչյուր խնդրի համար կա օրինաչափություն, և այստեղ դա կոնտրակտային թեստավորումն է։ Տեսնենք, թե ինչպես է այն օգնում թեստավորել միկրոսերվիսները։
Մոնոլիտ ընդդեմ միկրոսերվիսների
Մոդուլային մոնոլիտն աշխատում է մեկ պրոցեսում, ինչը, կախված համատեքստից, կարող է լինել և՛ ուժեղ, և՛ թույլ կողմ։ Նրա մոդուլները միմյանց հետ խոսում են լոկալ ֆունկցիաների կանչերով, ուստի բիզնես ֆունկցիոնալության մատակարարումը ցանց չի պահանջում։ Արդյունքում այդ մոդուլները ստուգող յունիթ և ինտեգրացիոն թեստերը գրվում են նրանց հրապարակային API-ի դեմ։ Մոդուլի API-ի փոփոխությունը (օրինակ՝ մեթոդի սիգնատուրայի փոխելը) հանգեցնում է կոմպիլյացիայի սխալի։ Դա դժվարացնում է մոնոլիտի ներսում մոդուլների միջև հաղորդակցության կոնտրակտը խախտելը։
Միկրոսերվիսների դեպքում իրավիճակն ավելի բարդ է։ Բիզնես ֆունկցիոնալություն մատակարարելու համար նրանք պետք է խոսեն ցանցով, և կոմպիլյատորն այլևս չի կարող օգնել մեզ։ Մոդուլները անկախ են և բաշխված՝ գործնականում երկու առանձին հավելված, որոնք, հավանաբար, ունեն թեստավորման և դեպլոյմենտի իրենց սեփական փայփլայնները։
Ինչպե՞ս համոզվել, որ սերվիսները իրար հետ համագործակցում են, նախքան production-ի անցնելը
Ինտեգրացիոն թեստավորում
Ինտեգրացիոն թեստավորումը, հավանաբար, առաջինն է, ինչի մասին մտածում է մեծամասնությունը։ Սա այս հարցի բավականին ակնհայտ և մասամբ ճիշտ պատասխանն է։ Սակայն նախքան առաջ անցնելը կուզենայի բացատրել, թե ինչ նկատի ունեմ ինտեգրացիոն թեստեր ասելով, քանի որ մարդիկ դրանք տարբեր կերպ են սահմանում։ Ինձ համար ինտեգրացիոն թեստը ստուգում է, թե արդյոք համակարգի առանձին մշակված մասերը ճիշտ են աշխատում միասին և տրամադրում են պահանջներին համապատասխանող ֆունկցիոնալություն։ Նման թեստը կարող է ստուգել՝
- բացահայտված API (օրինակ՝ REST API)
- փոխազդեցություն մեկ այլ սերվիսի հետ
- հաղորդագրությունների արտադրում և սպառում
- ինտեգրացիա տվյալների բազայի հետ
Ինտեգրացիոն թեստերը պետք է կատարվեն մեկուսացված ձևով։ Այլ կերպ ասած, թեստերի աշխատանքի համար ոչ մի սերվիս չպետք է աշխատի։ Իրականում մենք պետք է կարողանանք դրանք գործարկել առհասարակ առանց ցանցային կապի։
Ինտեգրացիոն թեստերը լավ են համապատասխանում այն ստուգելուն, թե արդյոք սերվիսը (կամ մոդուլը) ճիշտ է աշխատում համակարգի մյուս մասերի՝ օրինակ տվյալների բազայի կամ այլ սերվիսների հետ։ Նրանց հիմնական նպատակը պետք է լինի հաստատել, որ բիզնես ֆունկցիոնալությունը վարվում է այնպես, ինչպես նախատեսված է։ Ցավոք, ես հաճախ եմ տեսել, որ դրանք օգտագործվում են սերվիսների միջև հաղորդակցության կոնտրակտները ստուգելու համար։ Այս մոտեցումն ունի որոշ թերություններ, ուստի եկեք դրանց ավելի սերտ նայենք։

Ենթադրենք, ուզում ենք ստուգել, թե ինչպես են հաղորդակցվում երկու սերվիս՝ order-ը և payment-ը։ Վերջինս բացահայտում է REST API՝ վճարումը սկսելու համար։ Order-service-ը պատասխանատու է պատվերներ ստեղծելու համար և յուրաքանչյուրի համար կանչում է payment-service-ը՝ վճարում ստեղծելու նպատակով։ Այս հաղորդակցության աշխատանքը հաստատելու համար մեզ պետք է առնվազն երկու հավաք ինտեգրացիոն թեստեր՝
- API-ի պահանջներին համապատասխանությունը ստուգող թեստեր։ Այս թեստերը ստուգում են, որ սերվիսը տվյալ հարցման համար վերադարձնում է սպասվող արդյունք՝ ներառյալ ուղին, հեդերները և մարմնի կառուցվածքը։ Դրանք պետք է գտնվեն payment-service-ում և ընդօրինակեն order-service-ի կողմից API-ի կանչը (տես Code 1)։
- թեստեր, որոնք ստուգում են, որ order-service-ը ճիշտ է կանչում payment-service-ի API-ն։ Այս թեստերը ստուգում են, որ HTTP կլիենտը ճիշտ է դիմում payment-service-ին։ Դրանք պետք է գտնվեն order-service-ում և հիմնվեն payment-service-ի stub-երի վրա (տես Code 2)։

Payment-service-ի բացահայտված API-ն ծածկվել էր ստորև բերված ինտեգրացիոն թեստով, որը գրված է Spock-ով և RestAssured-ով։
def "should initiate payment"() {
given:
//skipped
def request =
"""
{
"accountId": "$accountId",
"orderDescription": "My first order",
"quota": 128.5,
"paymentType": "TRANSFER_ONLINE",
"dueDate": "$dueDate"
}
"""
expect:
given()
.contentType(APPLICATION_JSON_VALUE)
.accept(APPLICATION_JSON_VALUE)
.and()
.body(request)
.when()
.put("/payment/%s".formatted(paymentId))
.then()
.assertThat()
.statusCode(200)
.body("status", equalTo("FINISHED"))
.body("paymentExternalId", equalTo("ext-%s".formatted(paymentId)))
}
Code 1. payment-service API ինտեգրացիոն թեստ
Թեստը ապացուցում է, որ API-ն վարվում է այնպես, ինչպես նախատեսել էր payment-service-ի թիմը։ Այն ստուգում է, որ API-ն ընդունում է նշված հարցումը և վերադարձնում սպասվող պատասխանը։ Այն նաև պետք է աշխատեցնի համապատասխան բիզնես տրամաբանությունը (այդ ստուգումները թեստում բաց են թողնված)։

Այդ ընթացքում order-service-ի թիմը՝ որպես կլիենտ, գրեց ինտեգրացիոն թեստեր պատվերի ստեղծման տրամաբանության համար։ Այս թեստը նույնպես գրված է Spock-ով, և այն payment-service-ը փոխարինում է WireMock-ի stub-ով։
def "should create order and initiate payment"() {
given:
//skipped
def expectedRequest =
"""
{
"accountId": "$accountId",
"quota": $quota,
"paymentType": "TRANSFER_ONLINE",
"dueDate": "$dueDate"
}
"""
def paymentServiceResponse =
"""
{
"paymentExternalId": "ext-$orderId",
"status": "FINISHED"
}
"""
and:
wiremockServer.stubFor(put(urlMatching("/payment/([a-fA-F0-9-]*)"))
.withRequestBody(equalToJson(expectedRequest))
.willReturn(
aResponse()
.withStatus(200)
.withHeader("Content-Type", "application/json")
.withHeader("Accept", "application/json")
.withBody(paymentServiceResponse)
)
)
expect:
sut.createOrder(accountId, orderId, quota).paymentProcessed() == true
}
Code 2. Պատվերի ստեղծման ինտեգրացիոն թեստ payment-service-ի stub-ով
Այստեղ payment-service-ի stub-երն օգտագործվում են պատվերի ստեղծման տրամաբանությունը ստուգելու համար։ Թեստը ենթադրություններ է անում կանչվող սերվիսի վարքի մասին (ինչպես արտացոլված է stub-երում)։
Այսպես, ի՞նչ խնդիր ունեն այս թեստերը։ Իրականում դրանք լավ են աշխատում այնքան ժամանակ, քանի դեռ յուրաքանչյուր թիմ ճշգրիտ գիտի, թե ինչպես է վարվում մյուս կողմը։ Երկուսն էլ պետք է իմանան, թե ինչպիսին են սպասվող հարցումը և վերադարձվող պատասխանը՝ իդեալականում առանց նրանց միջև կոնտրակտը երբևէ փոխելու անհրաժեշտության։
Արդյունքում սերվիսների համատեղ աշխատանքը կախված է մարդկանց հաղորդակցությունից և գիտելիքից։ Պատկերացրեք payment-service-ի թիմի մի անդամի, ով պատասխանում նկատում է անհամապատասխան անվանում և որոշում status դաշտը վերանվանել paymentStatus։ Դաշտը վերանվանելն ու ինտեգրացիոն թեստը թարմացնելը, որպեսզի այն անցնի, հեշտ է, և փոփոխությունը կարող է գնալ production։ Բայց եթե կլիենտի կոդը նույնպես չհարմարեցվի, սերվիսների միջև հաղորդակցությունը կխզվի։ Հենց producer-ը դեպլոյ արվի production-ում, կանչերը սկսում են ձախողվել, սերվիսը դառնում է անհասանելի, և ընկերությունը փող է կորցնում։
Որպեսզի API-ի սպասվող կոտրող փոփոխության մասին տեղեկացնի կլիենտներին, payment-service-ի թիմը պետք է իմանա, թե ովքեր են այդ կլիենտները։ Դրանից բացի, նրանք պետք է գնահատեն, թե արդյոք փոփոխությունն ազդում է նրանց վրա, ինչը պահանջում է իմանալ, թե ինչպես են կլիենտները օգտագործում API-ն։ Ինտեգրացիոն թեստերը դա չեն կարող ասել։ Նրանք միայն արձանագրում են կոնտրակտի մասին որոշ ենթադրություններ և ոչ մի երաշխիք չեն տալիս, որ production-ում կլիենտներն իսկապես այդպես են օգտագործում API-ն։
Այս մոտեցման մեկ այլ թերությունն այն է, որ աշխատանքը կատարվում է երկու անգամ։ Երկու սերվիսների հաղորդակցության թեստավորումը պահանջում է երկու հավաք թեստեր, որոնք սովորաբար առանձին են գտնվում կլիենտի և producer-ի ռեպոզիտորիաներում։ Ավելի վատ՝ ոչինչ չի պահում դրանք համաժամեցված։ Երբ կլիենտի թիմը փոխում է կոնտրակտը, producer-ի կոդը դա չի արտացոլում, և հակառակը։
Image 1. Յուրաքանչյուր կողմի ինտեգրացիոն թեստերը գտնվում են առանձին ռեպոզիտորիաներում և համաժամեցված չեն։
Վերջապես, API-ի ինտեգրացիոն թեստերը հակված են բավականին տաղտկալի և կրկնվող լինել։ When բաժինը կանչում է թեստավորվող API-ն, ապա թեստը ստուգում է, որ սպասվող արդյունքը վերադարձվել է՝ դաշտ առ դաշտ, պատասխանի յուրաքանչյուր դաշտի համար։
Գոյություն ունի՞ դա թեստավորելու ավելի լավ միջոց։ Դրան կանդրադառնանք հոդվածի հաջորդ մասերում։
End-to-end թեստավորում
Սկսեմ end-to-end թեստերի սահմանումից։ Սրանք թեստեր են, որոնք ստուգում են, թե արդյոք ամբողջ համակարգը վարվում է այնպես, ինչպես սպասվում է։ Դրանք աշխատում են իրական սերվիսների օրինակների դեմ՝ առանց մեկուսացման, սովորաբար դեպլոյ արված այսպես կոչված stage միջավայրում։ Նրանց խնդիրը հաստատելն է, որ հիմնական բիզնես սցենարները ճիշտ են աշխատում։
End-to-end թեստերը չեն տառապում վերը նկարագրված խնդրից, բայց ունեն իրենց թերությունները։ Ամենակարևորներից մեկն այն է, որ թեստերը կատարելուց առաջ յուրաքանչյուր միկրոսերվիս պետք է դեպլոյ արված և աշխատող լինի։ Ուստի նման միջավայրը կարգավորելն ու պահպանելը դժվար է։ Մոտեցումը նաև բավականին ծախսատար է, քանի որ թեստերը գործարկելու համար պահանջվում են ենթակառուցվածք և ժամանակ։ Երկու սերվիսների միջև կոնտրակտը մեկուսացված ձևով ստուգել հնարավոր չէ՝ մեզ պետք է ենթակառուցվածք, որտեղ կոդն արդեն դեպլոյ արված է։ Դա անհարմար է և հակասում է թույլ կապակցված, անկախ դեպլոյ արվող սերվիսների միկրոսերվիսային փիլիսոփայությանը։
Կոնտրակտային թեստերը օգնության են գալիս
Կոնտրակտային թեստերը գտնվում են ինտեգրացիոն և e2e թեստերի միջև ինչ-որ տեղ։ Գաղափարը թույլ է տալիս մեկուսացված ձևով ստուգել, որ երկու սերվիս ճիշտ են հաղորդակցվում։ Այն հիմնվում է պարզ ենթադրության վրա. եթե consumer-ը և producer-ը անկախաբար թեստավորվեն նույն կոնտրակտի դեմ, նրանք կկարողանան ճիշտ հաղորդակցվել։ Սա է կոնտրակտային թեստավորման էությունը։ Գոյություն ունի ճիշտ մեկ ընդհանուր կոնտրակտ, որը նկարագրում է, թե ինչպես են սերվիսները խոսում միմյանց հետ՝ սինխրոն թե ասինխրոն, և թե consumer-ի, թե producer-ի թեստերը ածանցվում են դրանից։ Ինտեգրացիոն թեստավորումն այլ կերպ է աշխատում՝ այնտեղ ունենք երկու անկախ հավաք թեստեր, որոնք համաժամեցնելու ավտոմատ միջոց չկա։
Գործնականում կոնտրակտը փաստաթուղթ է, որը նկարագրում է հաղորդակցությունը DSL-ի (Domain Specific Language) միջոցով։ Կախված ֆրեյմվորքից՝ այն կարող է արտահայտվել տարբեր լեզուներով և նոտացիաներով, ինչպիսիք են Java, Groovy, JSON, YAML և այլն։ Ստորև բերված է Java-ով գրված կոնտրակտի օրինակ (Pact ֆրեյմվորք)։
builder
.given("test PUT)
.uponReceiving(“PUT REQUEST")
.path(“/payment”)
.headers(expectedHeaders)
.method(“PUT”)
.willRespondWith()
.status(200)
.headers(headers)
.body(“{\”accepted\”: true}")
Producer և consumer ի՞նչ են
Այս երկու եզրույթները անընդհատ հանդիպում են կոնտրակտային թեստերի մասին խոսելիս։
Producer-ը (երբեմն կոչվում է provider) սերվիսն է, որը բացահայտում է API։ Հաղորդագրությունների վրա հիմնված հաղորդակցության դեպքում դա սերվիսն է, որը հրապարակում է հաղորդագրություններ։
Consumer-ը սերվիսն է, որն օգտագործում է producer-ի բացահայտած API-ն կամ սպառում է նրա հրապարակած հաղորդագրությունները։
Այս հոդվածում producer-ը API-ն բացահայտող սերվիսն է, իսկ consumer-ը՝ այն օգտագործողը։
Ինչպե՞ս է կոնտրակտային թեստավորումն օգնում
Եկեք հիմա տեսնենք, թե ինչպես է այն լուծում ինտեգրացիոն թեստավորման խնդիրները։
Առաջին խնդիրն այն էր, որ մի կողմը կարող էր խախտել կոնտրակտը՝ առանց մյուսին ասելու։ Դա հնարավոր էր ինտեգրացիոն թեստերով, բայց կոնտրակտային թեստերը դա դժվարացնում են, քանի որ կոնտրակտի մեկ ընդհանուր սահմանում կա։ Երբ producer-ը (payment-service-ի թիմը) փոխում է, ասենք, պատասխանը, փոփոխությունը պետք է արվի նաև կոնտրակտում, հակառակ դեպքում producer-ի թեստերը կձախողվեն։ Իսկ երբ կոնտրակտը փոխվում է, consumer-ի թեստերը նույնպես թարմացվում են և, ամենայն հավանականությամբ, կձախողվեն, եթե փոփոխությունը հետադարձ համատեղելի չէ։ Սա ստիպում է թիմերին փոփոխությունների մասին միմյանց տեղեկացնել՝ կոնտրակտը ունենալով որպես հիմք։

Քանի որ հաղորդակցության յուրաքանչյուր մանրամասն արձանագրված է կոնտրակտում, producer թիմը (payment-service) ճշգրիտ գիտի, թե ով է օգտագործում իր API-ն և ինչպես։ Կոնտրակտները սովորաբար գտնվում են producer-ի ռեպոզիտորիայում (կամ առանձին՝ նվիրված ռեպոզիտորիայում)։ Երբ մեկ API-ն օգտագործում են մի քանի կլիենտներ, յուրաքանչյուր ինտեգրացիա ստանում է իր սեփական կոնտրակտը, քանի որ կոնտրակտները սահմանվում են ըստ կլիենտի։ Սա producer թիմին թույլ է տալիս հեշտությամբ բացահայտել կանչողներին։ Ենթադրենք, ուզում ենք հեռացնել կամ փոփոխել պատասխանի որևէ դաշտ։ Յուրաքանչյուր կլիենտի հետ համաձայնեցված կոնտրակտներով մենք կարող ենք պարզապես ստուգել՝ այդ դաշտը օգտագործվո՞ւմ է։ Սա API-ների զարգացումը դարձնում է շատ ավելի ճկուն։
Կախված ֆրեյմվորքից՝ մեզ գուցե ընդհանրապես պետք չլինի թեստեր կամ stub-եր պահպանել։ Producer-ի թեստերը գեներացվում են կոնտրակտից, ուստի մենք դրանք չենք գրում, և դրանք ստուգում են, որ API-ն վարվում է այնպես, ինչպես սահմանում է կոնտրակտը։ Consumer-ի կողմում թեստերը հիմնվում են stub-երի վրա, որոնք գեներացվում են հենց նույն կոնտրակտից։ Սա երկու կողմերին պահում է համաժամեցված հաղորդակցության և դրա թեստերի առումով, ինչպես նաև նվազեցնում է ձեռքով գրվող կոդի քանակը։
Վերջապես, կոնտրակտը ծառայում է որպես փաստաթղթավորման մի ձև այն մասին, թե ինչպես են սերվիսները կապակցված։ Հաղորդակցության երկու կողմերն էլ ստեղծում և համաձայնեցնում են այն, ուստի այն արձանագրում է նրանց պայմանավորվածությունները։ Որոշ ֆրեյմվորքեր կարող են նույնիսկ կոնտրակտից OpenAPI փաստաթղթավորում արտադրել՝ մեզ տալով API-ի մասին ճշմարտության մեկ աղբյուր։
Մի խոսքով, այս մոտեցմամբ պահպանելու միակ բանը կոնտրակտն է, որը նկարագրում է, թե ինչպես են սերվիսները հաղորդակցվում։ Թե՛ producer-ի, թե՛ consumer-ի թեստերը կատարվում են այնտեղ սահմանված կանոնների դեմ։ Սա մեզ վստահություն է տալիս, որ յուրաքանչյուր կողմ ճիշտ է իրականացված, և որ նրանք կարող են աշխատել միասին։
Ո՞ւմ է պատկանում կոնտրակտը
Ինչպես բացատրեցի, կոնտրակտային թեստավորումն ունի մեկ տեղ, որտեղ սահմանվում է կոնտրակտը։ Սա բնականաբար հարց է առաջացնում, թե ով է պատասխանատու այն սահմանելու և պահպանելու համար։ Կախված այն բանից, թե ինչպես են կապված ներգրավված սերվիսները (և նրանց թիմերը), գոյություն ունեն թեստավորման երկու մոտեցում՝
Consumer-Driven կոնտրակտային թեստավորում
Երբ producer-ը downstream սերվիս է, որը պետք է փորձի բավարարել consumer-ների կարիքները, կիրառվում է Consumer Driven ռազմավարությունը։ Այստեղ consumer-ները ձևավորում են հաղորդակցության կոնտրակտը՝ producer-ին ասելով, թե ինչպիսին պետք է լինի API-ն։ Բնականաբար, producer թիմը պետք է վերանայի, քննարկի և հաստատի նման համաձայնությունը։ Սա սովորաբար տեղի է ունենում այսպես. consumer թիմը կոնտրակտների ռեպոզիտորիայում բացում է Pull Request, որը producer թիմը վերանայում է և ի վերջո իրականացնում։

Այս մոտեցումն ունի մի քանի առավելություն՝
- քանի որ կոնտրակտը գրված և հաստատված է, consumer թիմին պետք չէ սպասել, մինչև producer-ը կառուցի ֆիչան։ Նրանք կարող են կոնտրակտից stub-եր գեներացնել և դրանցով թեստավորել սերվիսի ինտեգրացիան
- producer-ը գիտի, թե ով և ինչպես է օգտագործում իր API-ն
Այս մոտեցմամբ consumer և producer թիմերը կարող են, օրինակ, իրենց աշխատանքը համակարգել հետևյալ հոսքով՝
- Ենթադրենք, order-service-ի (consumer) համար պատասխանատու թիմը կառուցում է նոր ֆիչա, որը պետք է ինտեգրվի payment-service-ի (producer) հետ։ TDD կիրառելիս նրանք պարզում են, որ իրենց API-ի stub է պետք։
- Թիմերը քննարկում են կոնտրակտը և սահմանում այն DSL-ով։ Այն ստեղծվում և commit է արվում payment-service-ի ռեպոզիտորիայում։
- Producer-ի API-ի թեստերը գեներացվում են կոնտրակտից։ Այս պահին դրանք ձախողվում են, քանի որ իրականացումը բացակայում է։
- Կոնտրակտները և թեստերը push են արվում ռեպոզիտորիա։ Կարող է նաև pull request բացվել, որպեսզի producer թիմը վերցնի այն։
- Payment-service-ի stub-երը գեներացվում են թեստերի հետ միասին և կարող են հրապարակվել artifact ռեպոզիտորիայում (օրինակ՝ Artifactory)։
- Stub-երի օգնությամբ consumer թիմը կարող է ավարտել իր թեստերը։
Սա ցույց է տալիս, որ producer-ը պարտավոր չէ ավարտել իր իրականացումը, որպեսզի consumer-ը շարունակի իրենը։ Բնականաբար, ոչինչ չի կարող գնալ production, քանի դեռ producer թիմը չի իրականացրել այն, բայց consumer-ը չի արգելակվում։
Ի վերջո, producer թիմը պետք է իրականացնի API-ն կոնտրակտին համապատասխան։ Երբ բոլոր թեստերն անցնեն, սերվիսը կարելի է դեպլոյ անել production։ Քանի որ consumer-ի HTTP կլիենտը և producer-ի API-ն երկուսն էլ կառուցվել և թեստավորվել են մեկ կոնտրակտի դեմ, մենք կարող ենք վստահ լինել, որ սերվիսները production-ում ճիշտ կհաղորդակցվեն։
Սակայն կա մեկ դժվարություն։ Այս ամենը աշխատում է միայն այն դեպքում, եթե յուրաքանչյուր consumer խաղում է կանոններով։ Մեկ consumer-ը, որը կոնտրակտ չի ստեղծում, կարող է խարխլել ամբողջ գաղափարը։ Սա սովորաբար հեշտ է ապահովել՝ պահանջելով, որ consumer-ները ստեղծեն և համաձայնեցնեն կոնտրակտ, նախքան մեր սերվիսի հետ ինտեգրվելը։ Դա կարելի է ապահովել նաև տեխնիկապես, օրինակ՝ արգելափակելով մեր սերվիսի ingress-ը։
Producer-Driven կոնտրակտային թեստավորում
Ընդհակառակը, մեր սերվիսը կարող է օգտագործվել շատերի կողմից, որոնց մեծ մասին մենք գուցե նույնիսկ չենք էլ ճանաչում։ Այդ իրավիճակում մենք չենք կարող ճշգրիտ իմանալ, թե ով և ինչպես է ուզում օգտագործել մեր API-ն։ Այս մոտեցումը նաև հարմար է, երբ չենք ուզում, որ կլիենտները (consumer-ները) ազդեցություն ունենան մեր API-ի վրա։ Այստեղ producer-ը upstream սերվիս է. այն սահմանում է API կոնտրակտը և ասում consumer-ներին, թե ինչպես ինտեգրվել իր հետ։ Consumer-ները կարող են այս կոնտրակտները դիտարկել որպես փաստաթղթավորում, ինչպես նաև օգտագործել դրանք producer-ի հետ իրենց ինտեգրացիան թեստավորելու համար՝ առանց սերվերի վրա կոդ դեպլոյ անելու։

Կոնտրակտային թեստավորման թակարդը
Ես հաճախ եմ տեսել, որ մարդիկ չարաշահում են կոնտրակտային թեստավորումը, և ինքս էլ նույն սխալն եմ թույլ տվել։ Չարաշահում ասելով նկատի ունեմ կոնտրակտային թեստերի վրա հույս դնելը՝ յունիթ կամ ինտեգրացիոն թեստերի փոխարեն։ Կոնտրակտային թեստավորումը նախատեսված է սինխրոն կամ ասինխրոն հաղորդակցվող սերվիսների կոնտրակտը ստուգելու համար, այլ ոչ թե տրամաբանությունը վավերացնելու։
Որպես օրինակ վերցնենք payment-service-ի API-ն, որը պատասխանում վերադարձնում է status դաշտը։ Կախված սցենարից՝ նրա արժեքը կարող է լինել FINISHED, IN_PROGRESS կամ FAILED։ Սակայն այն, թե որ արժեքն է վերադարձվում, բիզնես պրոցեսի ներքին տրամաբանությունն է։ Դա, ամենայն հավանականությամբ, պետք է ծածկվի յունիթ թեստերով, այլ ոչ կոնտրակտային։ Դաշտի յուրաքանչյուր արժեքի համար առանձին կոնտրակտային թեստի սցենար պետք չէ՝ բավական է մեկը, որը ստուգում է, որ դաշտը վերադարձվում է այդ արժեքներից որևէ մեկով։
Իրավիճակը տարբեր է, երբ որոշակի հարցումը տարբեր պատասխան է առաջացնում։ Դա կարող է լինել, օրինակ, դրոշակ, որի պատճառով պատասխանում հայտնվում է լրացուցիչ դաշտ, կամ սխալի դեպք, երբ producer-ը անվավեր հարցմանը պատասխանում է 400 HTTP կարգավիճակով։ Նման դեպքերը պետք է ծածկվեն կոնտրակտային թեստերով, քանի որ դրանք հաղորդակցության առանձին իրավիճակ են ներկայացնում։
Եթե շարունակենք՝ 400 կոդը վերադարձվում է 3 սցենարում, և պատասխանները տարբերվում են միայն հաղորդագրությամբ, ապա մեկ կոնտրակտային թեստի սցենարը բավական է։
Ամփոփում
Մենք սկսեցինք միկրոսերվիսային ճարտարապետությունում հաղորդակցությունը թեստավորելու դժվարությունների ընդգծումից և դիտարկեցինք այն թեստավորելու երկու տարածված եղանակ՝ ինտեգրացիոն և e2e թեստավորում։ Այնուհետև ներկայացրինք կոնտրակտային թեստավորումը՝ որպես այդ խնդիրները լուծելու միջոց։
Կոնտրակտային թեստավորումը մոտեցում է, որը հնարավորություն է տալիս մեկուսացված ձևով թեստավորել սերվիսների միջև հաղորդակցությունը (թե՛ սինխրոն, թե՛ ասինխրոն)։ Նրա կենտրոնական գաղափարը կոնտրակտն է՝ այն վայրը, որտեղ երկու կողմերը համաձայնում են և արձանագրում հաղորդակցության կանոնները։ Կոնտրակտը սահմանվում է մեկ ընդհանուր վայրում, ուստի կողմերը կարիք չունեն համակարգվելու ամեն անգամ, երբ այն փոխվում է։ Թե՛ producer-ի, թե՛ consumer-ի թեստերը կառուցվում են այս կոնտրակտի վրա, ինչը երաշխավորում է, որ եթե դրանք անցնում են, սերվիսները production-ում կաշխատեն միասին։
Դրանից հետո նկարագրեցի, թե ինչպես են տարբերվում Consumer Driven և Producer Driven մոտեցումները և երբ է յուրաքանչյուրը հարմար։ Վերջապես, կիսվեցի խորհրդով, թե ինչպես խուսափել կոնտրակտային թեստավորումը չարաշահելու թակարդից։
Առաջիկա հոդվածներում ես կներկայացնեմ կոնտրակտային թեստավորման երկու ամենաշատ օգտագործվող ֆրեյմվորքները՝ Spring Cloud Contract-ը և Pact-ը։ Հետևե՛ք մեզ։