TypeScript-da testlash: Mustahkam kod uchun tur xavfsiz testlarni amalga oshirish strategiyalari

Dasturiy ta'minotni ishlab chiqish sohasida kod sifatini ta'minlash muhim ahamiyatga ega. TypeScript, o'zining kuchli terish tizimi bilan, yanada ishonchli va texnik xizmat ko'rsatishga yaroqli ilovalarni yaratish uchun noyob imkoniyatni taqdim etadi. Ushbu maqola turli TypeScript testlash strategiyalarini o'rganadi va tur xavfsizligidan qanday qilib mustahkam va samarali testlarni yaratishda foydalanishni ta'kidlaydi. Biz turli testlash usullari, freymvorklar va eng yaxshi amaliyotlarni o'rganamiz va sizga TypeScript testlash bo'yicha keng qamrovli qo'llanmani taqdim etamiz.

Testlashda tur xavfsizligi nima uchun muhim?

TypeScript-ning statik terish tizimi testlashda bir nechta afzalliklarni taqdim etadi:

• Erta xatolarni aniqlash: TypeScript ish vaqtida xatoliklar ehtimolini kamaytirib, ishlab chiqish vaqtida tur bilan bog'liq xatolarni aniqlashi mumkin.
• Kodning texnik xizmat ko'rsatish qobiliyatini yaxshilash: Turlar kodni tushunishni va qayta tuzishni osonlashtiradi, bu esa yanada texnik xizmat ko'rsatishga yaroqli testlarga olib keladi.
• Test qamrovini oshirish: Tur haqida ma'lumot yanada keng qamrovli va maqsadli testlarni yaratishga yordam beradi.
• Nosozliklarni tuzatish vaqtini qisqartirish: Tur xatolarini ish vaqtidagi xatolarga qaraganda tashxislash va tuzatish osonroq.

Testlash darajalari: Keng qamrovli umumiy ko'rinish

Mustahkam testlash strategiyasi keng qamrovli qamrovni ta'minlash uchun bir nechta testlash darajalarini o'z ichiga oladi. Ushbu darajalar quyidagilarni o'z ichiga oladi:

• Unit testlash: Individual komponentlar yoki funktsiyalarni alohida sinovdan o'tkazish.
• Integratsiya testlash: Turli birliklar yoki modullar o'rtasidagi o'zaro ta'sirni sinovdan o'tkazish.
• Oxiridan-oxirigacha (E2E) testlash: Butun ilova ish jarayonini foydalanuvchi nuqtai nazaridan sinovdan o'tkazish.

TypeScript-da unit testlash: Komponent darajasidagi ishonchlilikni ta'minlash

Unit testlash freymvorkini tanlash

TypeScript uchun bir nechta mashhur unit testlash freymvorklari mavjud, jumladan:

• Jest: Mocking, kod qamrovi va snapshot testlash kabi o'rnatilgan xususiyatlarga ega keng qamrovli testlash freymvorki. U foydalanish qulayligi va mukammal ishlashi bilan mashhur.
• Mocha: Tasdiqlash va mocking kabi xususiyatlar uchun qo'shimcha kutubxonalarni talab qiladigan moslashuvchan va kengaytiriladigan testlash freymvorki.
• Jasmine: Toza va o'qiladigan sintaksisga ega yana bir mashhur testlash freymvorki.

Ushbu maqola uchun biz asosan Jest-dan uning soddaligi va keng qamrovli xususiyatlari uchun foydalanamiz. Biroq, muhokama qilingan tamoyillar boshqa freymvorklarga ham tegishli.

Misol: TypeScript funktsiyasini unit testlash

Chegirma miqdorini hisoblaydigan quyidagi TypeScript funktsiyasini ko'rib chiqing:

            // src/discountCalculator.ts
export function calculateDiscount(price: number, discountPercentage: number): number {
  if (price < 0 || discountPercentage < 0 || discountPercentage > 100) {
    throw new Error("Noto'g'ri kiritish: Narx va chegirma foizi manfiy bo'lmasligi kerak va chegirma foizi 0 dan 100 gacha bo'lishi kerak.");
  }
  return price * (discountPercentage / 100);
}

            

              
                Copy
              
            
          

Mana, Jest yordamida ushbu funktsiya uchun qanday unit test yozishingiz mumkin:

            // test/discountCalculator.test.ts
import { calculateDiscount } from '../src/discountCalculator';

describe('calculateDiscount', () => {
  it('chegirma miqdorini to'g'ri hisoblashi kerak', () => {
    expect(calculateDiscount(100, 10)).toBe(10);
    expect(calculateDiscount(50, 20)).toBe(10);
    expect(calculateDiscount(200, 5)).toBe(10);
  });

  it('nol chegirma foizini to'g'ri boshqarishi kerak', () => {
    expect(calculateDiscount(100, 0)).toBe(0);
  });

  it('100% chegirmaga to'g'ri ishlov berishi kerak', () => {
    expect(calculateDiscount(100, 100)).toBe(100);
  });

  it('noto'g'ri kiritish uchun xato tashlashi kerak (manfiy narx)', () => {
    expect(() => calculateDiscount(-100, 10)).toThrowError("Noto'g'ri kiritish: Narx va chegirma foizi manfiy bo'lmasligi kerak va chegirma foizi 0 dan 100 gacha bo'lishi kerak.");
  });

  it('noto'g'ri kiritish uchun xato tashlashi kerak (manfiy chegirma foizi)', () => {
    expect(() => calculateDiscount(100, -10)).toThrowError("Noto'g'ri kiritish: Narx va chegirma foizi manfiy bo'lmasligi kerak va chegirma foizi 0 dan 100 gacha bo'lishi kerak.");
  });

  it('noto'g'ri kiritish uchun xato tashlashi kerak (chegirma foizi > 100)', () => {
    expect(() => calculateDiscount(100, 110)).toThrowError("Noto'g'ri kiritish: Narx va chegirma foizi manfiy bo'lmasligi kerak va chegirma foizi 0 dan 100 gacha bo'lishi kerak.");
  });
});

            

              
                Copy
              
            
          

Ushbu misol TypeScript-ning tur tizimi funktsiyaga to'g'ri ma'lumotlar turlari uzatilishini va testlar turli xil stsenariylarni, shu jumladan chekka holatlar va xato sharoitlarini qamrab olishini ta'minlashga qanday yordam berishini ko'rsatadi.

Unit testlarda TypeScript turlaridan foydalanish

TypeScript-ning tur tizimi unit testlarning aniqligi va texnik xizmat ko'rsatish qobiliyatini yaxshilash uchun ishlatilishi mumkin. Misol uchun, funktsiyalar tomonidan qaytarilgan ob'ektlarning kutilgan tuzilishini aniqlash uchun interfeyslardan foydalanishingiz mumkin:

            interface User {
  id: number;
  name: string;
  email: string;
}

function getUser(id: number): User {
  // ... amalga oshirish ...
  return { id: id, name: "John Doe", email: "john.doe@example.com" };
}

it('to'g'ri xususiyatlarga ega bo'lgan foydalanuvchi ob'ektini qaytarishi kerak', () => {
  const user = getUser(123);
  expect(user.id).toBe(123);
  expect(user.name).toBe('John Doe');
  expect(user.email).toBe('john.doe@example.com');
});

            

              
                Copy
              
            
          

`User` interfeysidan foydalanib, siz testning to'g'ri xususiyatlar va turlarni tekshirishini ta'minlaysiz, bu esa uni yanada mustahkam qiladi va xatolarga kamroq moyil bo'ladi.

TypeScript bilan mocking va stubbing

Unit testlashda test ostidagi unitni uning bog'liqliklarini mocking yoki stubbing orqali izolyatsiya qilish ko'pincha zarur. TypeScript-ning tur tizimi mocking va stublarning to'g'ri amalga oshirilishini va ular kutilgan interfeyslarga rioya qilishini ta'minlashga yordam beradi.

Ma'lumotlarni olish uchun tashqi xizmatga tayanadigan funktsiyani ko'rib chiqing:

            interface DataService {
  getData(id: number): Promise;
}

class MyComponent {
  constructor(private dataService: DataService) {}

  async fetchData(id: number): Promise {
    return this.dataService.getData(id);
  }
}

            

              
                Copy
              
            
          

`MyComponent`ni test qilish uchun siz `DataService`ning mocking amalga oshirilishini yaratishingiz mumkin:

            class MockDataService implements DataService {
  getData(id: number): Promise {
    return Promise.resolve(`Data for id ${id}`);
  }
}

it('ma'lumotlar xizmatidan ma'lumotlarni olishi kerak', async () => {
  const mockDataService = new MockDataService();
  const component = new MyComponent(mockDataService);
  const data = await component.fetchData(123);
  expect(data).toBe('Data for id 123');
});

            

              
                Copy
              
            
          

`DataService` interfeysini amalga oshirib, `MockDataService` kerakli usullarni to'g'ri turlar bilan ta'minlashni ta'minlaydi va testlash vaqtida tur bilan bog'liq xatolarning oldini oladi.

TypeScript-da integratsiya testlash: Modullar o'rtasidagi o'zaro ta'sirni tekshirish

Integratsiya testlash ilova ichidagi turli birliklar yoki modullar o'rtasidagi o'zaro ta'sirni tekshirishga qaratilgan. Testlashning bu darajasi tizimning turli qismlari birgalikda to'g'ri ishlashini ta'minlash uchun juda muhimdir.

Misol: Ma'lumotlar bazasi bilan integratsiya testlash

Ma'lumotlarni saqlash va olish uchun ma'lumotlar bazasi bilan o'zaro aloqada bo'ladigan ilovani ko'rib chiqing. Ushbu ilova uchun integratsiya testi quyidagilarni o'z ichiga olishi mumkin:

• Test ma'lumotlar bazasini o'rnatish.
• Ma'lumotlar bazasini test ma'lumotlari bilan to'ldirish.
• Ma'lumotlar bazasi bilan o'zaro aloqada bo'ladigan ilova kodini bajarish.
• Ma'lumotlarning to'g'ri saqlanganligi va olinganligini tekshirish.
• Test tugagandan so'ng test ma'lumotlar bazasini tozalash.

            // integration/userRepository.test.ts
import { UserRepository } from '../src/userRepository';
import { DatabaseConnection } from '../src/databaseConnection';

describe('UserRepository', () => {
  let userRepository: UserRepository;
  let databaseConnection: DatabaseConnection;

  beforeAll(async () => {
    databaseConnection = new DatabaseConnection('test_database'); // Alohida test ma'lumotlar bazasidan foydalaning
    await databaseConnection.connect();
    userRepository = new UserRepository(databaseConnection);
  });

  afterAll(async () => {
    await databaseConnection.disconnect();
  });

  beforeEach(async () => {
    // Har bir testdan oldin ma'lumotlar bazasini tozalang
    await databaseConnection.clearDatabase();
  });

  it('ma'lumotlar bazasida yangi foydalanuvchi yaratishi kerak', async () => {
    const newUser = { id: 1, name: 'Alice', email: 'alice@example.com' };
    await userRepository.createUser(newUser);

    const retrievedUser = await userRepository.getUserById(1);
    expect(retrievedUser).toEqual(newUser);
  });

  it('ID bo'yicha ma'lumotlar bazasidan foydalanuvchini olishi kerak', async () => {
    const existingUser = { id: 2, name: 'Bob', email: 'bob@example.com' };
    await userRepository.createUser(existingUser);

    const retrievedUser = await userRepository.getUserById(2);
    expect(retrievedUser).toEqual(existingUser);
  });
});

            

              
                Copy
              
            
          

Ushbu misol test muhitini qanday o'rnatishni, ma'lumotlar bazasi bilan o'zaro aloqada bo'lishni va ilova kodi ma'lumotlarni to'g'ri saqlashini va olishini tekshirishni ko'rsatadi. Ma'lumotlar bazasi ob'ektlari uchun TypeScript interfeyslaridan (masalan, `User`) foydalanish integratsiya testlash jarayonida tur xavfsizligini ta'minlaydi.

Integratsiya testlarida tashqi xizmatlarni mocking

Integratsiya testlarida ko'pincha ilova bog'liq bo'lgan tashqi xizmatlarni mocking qilish zarur. Bu sizning ilovangiz va xizmat o'rtasidagi integratsiyani haqiqiy xizmatga tayanmasdan testlashga imkon beradi.

Misol uchun, agar sizning ilovangiz to'lov shlyuzi bilan integratsiyalashgan bo'lsa, siz turli xil to'lov stsenariylarini simulyatsiya qilish uchun shlyuzning mocking amalga oshirilishini yaratishingiz mumkin.

TypeScript-da oxiridan-oxirigacha (E2E) testlash: Foydalanuvchi ish jarayonlarini simulyatsiya qilish

Oxiridan-oxirigacha (E2E) testlash butun ilova ish jarayonini foydalanuvchi nuqtai nazaridan sinovdan o'tkazishni o'z ichiga oladi. Testlashning bu turi ilovaning real muhitda to'g'ri ishlashini ta'minlash uchun juda muhimdir.

E2E testlash freymvorkini tanlash

TypeScript uchun bir nechta mashhur E2E testlash freymvorklari mavjud, jumladan:

• Cypress: Ilova bilan foydalanuvchi o'zaro ta'sirini simulyatsiya qiladigan testlarni yozishga imkon beradigan kuchli va qulay E2E testlash freymvorki.
• Playwright: TypeScript-ni o'z ichiga olgan bir nechta dasturlash tillarini qo'llab-quvvatlaydigan brauzerlararo testlash freymvorki.
• Puppeteer: Boshsiz Chrome yoki Chromium-ni boshqarish uchun yuqori darajadagi API-ni taqdim etadigan Node kutubxonasi.

Cypress foydalanish qulayligi va keng qamrovli xususiyatlari tufayli veb-ilovalar uchun E2E testlash uchun ayniqsa mos keladi. Playwright brauzerlararo moslik va ilg'or xususiyatlar uchun juda yaxshi. Biz Cypress yordamida E2E testlash tushunchalarini namoyish etamiz.

Misol: Cypress bilan E2E testlash

Kirish formasi bilan oddiy veb-ilovani ko'rib chiqing. Ushbu ilova uchun E2E testi quyidagilarni o'z ichiga olishi mumkin:

• Kirish sahifasiga tashrif buyurish.
• Yaroqli ma'lumotlarni kiritish.
• Formani topshirish.
• Foydalanuvchi bosh sahifaga yo'naltirilganligini tekshirish.

            // cypress/integration/login.spec.ts
describe('Login', () => {
  it('yaroqli ma'lumotlar bilan muvaffaqiyatli kirishi kerak', () => {
    cy.visit('/login');
    cy.get('#username').type('valid_user');
    cy.get('#password').type('valid_password');
    cy.get('button[type="submit"]').click();
    cy.url().should('include', '/home');
    cy.contains('Welcome, valid_user').should('be.visible');
  });

  it('noto'g'ri ma'lumotlar bilan xato xabarini ko'rsatishi kerak', () => {
    cy.visit('/login');
    cy.get('#username').type('invalid_user');
    cy.get('#password').type('invalid_password');
    cy.get('button[type="submit"]').click();
    cy.contains('Invalid username or password').should('be.visible');
  });
});

            

              
                Copy
              
            
          

Ushbu misol Cypress-dan foydalanib veb-ilova bilan foydalanuvchi o'zaro ta'sirini qanday simulyatsiya qilish va ilovaning kutilganidek ishlashini tekshirishni ko'rsatadi. Cypress DOM bilan o'zaro aloqada bo'lish, tasdiqlashlarni amalga oshirish va foydalanuvchi hodisalarini simulyatsiya qilish uchun kuchli API-ni taqdim etadi.

Cypress testlarida tur xavfsizligi

Cypress asosan JavaScript-ga asoslangan freymvork bo'lsa-da, E2E testlaringizning tur xavfsizligini yaxshilash uchun TypeScript-dan foydalanishingiz mumkin. Misol uchun, siz maxsus buyruqlarni aniqlash va API qo'ng'iroqlari tomonidan qaytarilgan ma'lumotlarni yozish uchun TypeScript-dan foydalanishingiz mumkin.

TypeScript testlash uchun eng yaxshi amaliyotlar

TypeScript testlaringiz samarali va texnik xizmat ko'rsatishga yaroqli bo'lishini ta'minlash uchun quyidagi eng yaxshi amaliyotlarni ko'rib chiqing:

• Testlarni erta va tez-tez yozing: Ishlab chiqish ish jarayoniga testlashni boshidan integratsiya qiling. Testga asoslangan dasturlash (TDD) - bu ajoyib yondashuv.
• Test qobiliyatiga e'tibor bering: Kodingizni oson testlash uchun loyihalashtiring. Komponentlarni ajratish va ularni mocking qilishni osonlashtirish uchun bog'liqlikni in'ektsiyalashdan foydalaning.
• Testlarni kichik va diqqat markazida saqlang: Har bir test kodning bitta jihatiga e'tibor qaratishi kerak. Bu testlarni tushunishni va texnik xizmat ko'rsatishni osonlashtiradi.
• Tavsiflovchi test nomlaridan foydalaning: Testning nima tekshirayotganini aniq tavsiflovchi test nomlarini tanlang.
• Test qamrovining yuqori darajasini saqlang: Kodning barcha qismlari adekvat sinovdan o'tkazilishini ta'minlash uchun yuqori test qamroviga intiling.
• Testlaringizni avtomatlashtiring: Kod o'zgarishlari kiritilganda testlarni avtomatik ravishda ishga tushirish uchun testlaringizni uzluksiz integratsiya (CI) quvuriga integratsiya qiling.
• Kod qamrovini o'lchash vositalaridan foydalaning: Test qamrovini o'lchash va kodning etarli darajada sinovdan o'tkazilmagan joylarini aniqlash uchun vositalardan foydalaning.
• Testlarni muntazam ravishda qayta tuzing: Kodingiz o'zgargan sari, testlaringizni dolzarb saqlash va texnik xizmat ko'rsatishga yaroqli bo'lishi uchun qayta tuzing.
• Testlaringizni hujjatlashtiring: Testning maqsadini va uning barcha taxminlarini tushuntirish uchun testlaringizga izohlar qo'shing.
• AAA naqshiga rioya qiling: Tartibga solish, Harakat qilish, Tasdiqlash. Bu testlaringizni o'qish uchun tuzishga yordam beradi.

Xulosa: Tur xavfsiz TypeScript testlash bilan mustahkam ilovalarni yaratish

TypeScript-ning kuchli terish tizimi mustahkam va texnik xizmat ko'rsatishga yaroqli ilovalarni yaratish uchun kuchli asosni ta'minlaydi. Testlash strategiyalaringizda tur xavfsizligidan foydalanib, siz xatolarni erta aniqlaydigan va kodingizning umumiy sifatini yaxshilaydigan yanada ishonchli va samarali testlarni yaratishingiz mumkin. Ushbu maqola unit testlashdan integratsiya testlashga va oxiridan-oxirigacha testlashga qadar turli TypeScript testlash strategiyalarini o'rganib chiqdi va sizga TypeScript testlash bo'yicha keng qamrovli qo'llanmani taqdim etdi. Ushbu maqolada keltirilgan eng yaxshi amaliyotlarga rioya qilib, siz TypeScript ilovalaringiz puxta sinovdan o'tkazilishini va ishlab chiqarishga tayyor bo'lishini ta'minlashingiz mumkin. Boshidanoq keng qamrovli testlash yondashuvini qabul qilish global miqyosda dasturchilarga yanada ishonchli va texnik xizmat ko'rsatishga yaroqli dasturiy ta'minotni yaratishga imkon beradi, bu esa foydalanuvchi tajribasini yaxshilashga va ishlab chiqish xarajatlarini kamaytirishga olib keladi. TypeScript-ni qabul qilish o'sishda davom etar ekan, tur xavfsiz testlashni o'zlashtirish butun dunyo bo'ylab dasturiy ta'minot muhandislari uchun tobora qimmatli mahoratga aylanadi.