Menguji layanan mikro terdistribusi dengan xstate – Beragampengetahuan

Arsitektur layanan mikro terdistribusi membawa skalabilitas dan modularitas, tetapi mereka juga memperkenalkan kompleksitas, terutama dalam hal orkestrasi layanan pengujian. Mengkoordinasikan beberapa layanan melalui ketergantungan asinkron dan skenario kegagalan seringkali dapat menghasilkan cakupan uji yang rapuh atau tidak lengkap.

XState adalah perpustakaan JavaScript dan TypeScript untuk mesin negara dan statecharts, memberikan solusi yang kuat untuk memodelkan dan menguji alur kerja ini. Dengan mewakili orkestrasi layanan mikro Anda sebagai mesin negara, Anda bisa mendapatkan sumber yang benar untuk perilaku yang Anda harapkan dan dapat secara sistematis mensimulasikan dan memverifikasi.

Dalam artikel ini, kami akan menunjukkan cara menggunakan XState untuk memodelkan alur kerja terdistribusi dan menghasilkan skenario uji visual, deklaratif, dan yang dapat dipelihara. Apakah Anda menguji penyediaan pengguna, pemrosesan pembayaran, atau jaringan pipa yang digerakkan oleh peristiwa, XState membantu memastikan semua transisi dan kasus tepi dipertimbangkan.

memperkenalkan

Arsitektur layanan mikro terdistribusi dapat diskalakan, modular dan tangguh, tetapi mereka juga memperkenalkan kompleksitas penting – terutama ketika mengoordinasikan dan menguji alur kerja. Ketika layanan berkomunikasi secara sinkron dan gagal secara mandiri, tes penulisan yang mencakup semua situasi yang mungkin menjadi semakin sulit. Coba lagi logika, kondisi ras, aliran mundur, dan kasus tepi semakin memperumit tugas, sering kali menghasilkan suite uji yang rapuh atau tidak lengkap.

Salah satu cara untuk mengontrol ulang kompleksitas ini adalah dengan menggunakan Mesin Negara Terbatas (FSM). XState adalah pustaka JavaScript dan TypeScript untuk membuat FSM dan Statecharts, memberikan abstraksi yang kuat untuk definisi, mengejek, dan menguji alur kerja. Dalam artikel ini, kami akan mengeksplorasi cara menggunakan XState untuk memodelkan orkestrasi layanan dan mendorong otomatisasi uji yang komprehensif dan dipertahankan.

Apa itu XState?

XState memungkinkan pengembang untuk mendefinisikan perilaku sistem berdasarkan keadaan, transisi, dan tindakan. Alih-alih melacak status orkestrasi melalui bendera, rantai IF-Else, dan panggilan balik, Anda dapat menentukan model proses formal. Model ini menjadi satu -satunya sumber kebenaran, memberikan visibilitas yang jelas ke dalam logika sistem dan membuatnya lebih mudah untuk diuji.

Dengan XState, setelah mesin negara didefinisikan, Anda dapat:

• Visualisasi transisi waktu nyata Xstate Visualizer
• Mensimulasikan peristiwa dan transisi negara untuk memastikan perilaku model Anda diharapkan
• Hasilkan jalur uji untuk memverifikasi semua hasil yang mungkin

Pendekatan ini menyediakan struktur untuk alur kerja yang kacau dan memungkinkan Anda untuk memvalidasi secara sistematis setiap bagian orkestrasi.

Use Case: Pemodelan Aliran Orkestrasi Microservice

Untuk menunjukkan xstate beraksi, mari kita pertimbangkan skema orkestrasi layanan mikro yang khas: pipa pemrosesan pesanan. Pipa melibatkan beberapa layanan ketergantungan seperti verifikasi inventaris dan pemrosesan pembayaran. Berikut adalah pandangan yang disederhanakan dari negara -negara yang terlibat:

• Harus dilakukan: Tunggu pengiriman perintah
• Pengolahan: Memanggil inventaris dan layanan pembayaran
• menyelesaikan: Kedua layanan berhasil diselesaikan
• Gagal: Satu atau lebih layanan mengalami kesalahan

Transisi mungkin terlihat seperti ini:

• Pesanan diterima → pemrosesan
• Keberhasilan Layanan → Implementasi
• Layanan Gagal → Gagal
• Coba lagi → proses

Menggunakan XState Kami dapat secara deklaratif memodelkan transisi ini dan kemudian menguji semua aliran yang mungkin dengan mengatur.

Implementasi Kode

Services.js

const Database = ;
function microservice1() 
    Database['user1'] = 
        name: 'John Doe',
        age: 30,
        email: '[email protected]',
    ;
    console.log('User added:', Database['user1']);


function microservice2() 
    if (Database['user1']) 
        Database['user1'].transaction = 
            amount: 100,
            date: '2023-10-01',
            status: 'completed',
        ;
        console.log('Transaction added:', Database['user1'].transaction);
     else 
        console.error('Error: User not found. Cannot add transaction.');
    



function getUserById(userId) 
    return Database[userId] 



export  microservice1, microservice2, getUserById, Database ;

Servicest.js

import  createMachine, interpret, send  from 'xstate';

import  microservice1, microservice2, getUserById  from './Services.js';



const serviceMachine = createMachine(
  
    id: 'serviceMachine',
    initial: 'idle',
    context: 
      database: null,
    ,
    states: 
      idle: 
        on:  START: 'addUser' ,
      ,
      addUser: 
        entry: 'invokeMicroservice1',
        on:  NEXT: 'addTransaction' ,
      ,
      addTransaction: 
        entry: 'invokeMicroservice2',
        on:  CHECK: 'checkDatabase' ,
      ,
      checkDatabase: 
        entry: 'checkDatabase',
        on: 
          SUCCESS: 'success',
          FAILURE: 'failure',
        ,
      ,
      success: 
        type: 'final',
        entry: () => console.log('Success: Database is valid!'),
      ,
      failure: 
        type: 'final',
        entry: () => console.log('Failure: Database validation failed!'),
      ,
    ,
  ,

  {
    actions: 
      invokeMicroservice1: () => 
        microservice1();
        console.log('Microservice1 executed: User added.');
      ,

      invokeMicroservice2: () => 
        microservice2();
        console.log('Microservice2 executed: Transaction added.');
      ,

      checkDatabase: send(() => 
        const user = getUserById('user1');
        if (user && user.name === 'John Doe' && user.transaction.amount === 100) 
          console.log('Validation passed.');
          return  type: 'SUCCESS' ;
         else 
          console.log('Validation failed.');
          return  type: 'FAILURE' ;
        
      ),
    ,
  }
);


const service = interpret(serviceMachine).start();


service.onTransition((state) => 
  console.log(`Current state: $state.value`);
);



service.send('START');

service.send('NEXT');

service.send('CHECK');

package.json

  "name": "xstatetests",
  "version": "1.0.0",
  "description": "A project demonstrating the use of XState for testing microservices",
  "main": "ServiceTest.js",
  "type": "module",
  "scripts": 
    "start": "node ServiceTest.js",
    "test": "echo \"No tests specified\" && exit 1"
  ,
  "author": "Akash Verma",
  "license": "ISC",
  "dependencies": 
    "xstate": "^4.36.0"
  ,

  "keywords": [
    "xstate",
    "state-machine",
    "workflow",
    "javascript"
  ]

Manfaat Pengujian Berbasis Model dengan XState

• Cakupan komprehensif: Memodelkan orkestrasi sebagai mesin negara bagian, dan Anda dapat menghasilkan tes yang mencakup semua status dan transisi yang mungkin. Tidak lagi mengandalkan tebakan.
• Pemeliharaan: Ketika logika bisnis berubah, Anda hanya perlu memperbarui mesin negara dan tes Anda akan berkembang secara otomatis.
• Mengurangi kesalahan: Dengan mensimulasikan casing tepi lebih awal, Anda dapat menangkap kesalahan integrasi sebelum mencapai produksi.
• Debugging visual: Gunakan alat seperti Xstate Visualzer untuk mengamati dan memverifikasi transisi keadaan secara real time.
• Skalabilitas: Saat alur kerja tumbuh, model Anda hadir dengannya – tidak ada logika pengujian salin.

sebagai kesimpulan

Menguji orkestrasi layanan mikro sangat sulit, tetapi tidak harus kacau. Dengan XState, Anda dapat membawa struktur, visibilitas, dan keandalan untuk pengujian integrasi. Apakah Anda menggunakan mesin negara dalam produksi atau tidak, memodelkan alur kerja untuk tujuan pengujian dapat meningkatkan cakupan, pemeliharaan, dan kepercayaan diri. Dengan memperlakukan negara sebagai warga negara terkemuka dalam sistem Anda, Anda mendapatkan alat yang Anda butuhkan untuk mensimulasikan perilaku yang kompleks dan menyediakan perangkat lunak yang kuat.

Lain kali Anda merancang mesin orkestrasi layanan, pertimbangkan untuk memulai dengan model. Itu dapat mengubah cara Anda menguji.