TypeScript Testēšana: Tipdroša Testu Implementācijas Stratēģijas Robustai Kodei

Programmatūras izstrādes jomā vissvarīgākais ir nodrošināt koda kvalitāti. TypeScript ar savu spēcīgo tipu sistēmu piedāvā unikālu iespēju izveidot uzticamākas un vieglāk uzturamas lietojumprogrammas. Šajā rakstā ir apskatītas dažādas TypeScript testēšanas stratēģijas, uzsverot, kā izmantot tipdrošību, lai izveidotu robustus un efektīvus testus. Mēs izpētīsim dažādas testēšanas pieejas, ietvarus un labāko praksi, sniedzot jums visaptverošu ceļvedi TypeScript testēšanai.

Kāpēc Tipdrošība Ir Svarīga Testēšanā

TypeScript statisko tipu sistēma nodrošina vairākas priekšrocības testēšanā:

• Agrīna Kļūdu Noteikšana: TypeScript var uztvert ar tipiem saistītas kļūdas izstrādes laikā, samazinot izpildlaika kļūmju iespējamību.
• Uzlabota Koda Uzturamība: Tipi atvieglo koda saprašanu un pārveidošanu, nodrošinot vieglāk uzturamus testus.
• Uzlabots Testu Pārklājums: Tipu informācija var palīdzēt izveidot visaptverošākus un mērķtiecīgākus testus.
• Samazināts Atkļūdošanas Laiks: Tipu kļūdas ir vieglāk diagnosticēt un novērst, salīdzinot ar izpildlaika kļūdām.

Testēšanas Līmeņi: Visaptverošs Pārskats

Robusta testēšanas stratēģija ietver vairākus testēšanas līmeņus, lai nodrošinātu visaptverošu pārklājumu. Šie līmeņi ietver:

• Vienību Testēšana: Atsevišķu komponentu vai funkciju testēšana izolācijā.
• Integrācijas Testēšana: Dažādu vienību vai moduļu mijiedarbības testēšana.
• Gala-līdz-galam (E2E) Testēšana: Visas lietojumprogrammas darbplūsmas testēšana no lietotāja perspektīvas.

Vienību Testēšana TypeScript: Komponentu Līmeņa Uzticamības Nodrošināšana

Vienību Testēšanas Ietvara Izvēle

TypeScript ir pieejami vairāki populāri vienību testēšanas ietvari, tostarp:

• Jest: Visaptverošs testēšanas ietvars ar iebūvētām funkcijām, piemēram, maketēšana, koda pārklājums un momentuzņēmumu testēšana. Tas ir pazīstams ar savu lietošanas vienkāršību un izcilu veiktspēju.
• Mocha: Elastīgs un paplašināms testēšanas ietvars, kuram ir nepieciešamas papildu bibliotēkas tādām funkcijām kā apgalvojums un maketēšana.
• Jasmine: Vēl viens populārs testēšanas ietvars ar tīru un lasāmu sintaksi.

Šajā rakstā mēs galvenokārt izmantosim Jest tā vienkāršības un visaptverošo funkciju dēļ. Tomēr apspriestie principi attiecas arī uz citiem ietvariem.

Piemērs: TypeScript Funkcijas Vienību Testēšana

Apsveriet šādu TypeScript funkciju, kas aprēķina atlaides summu:

            // src/discountCalculator.ts
export function calculateDiscount(price: number, discountPercentage: number): number {
  if (price < 0 || discountPercentage < 0 || discountPercentage > 100) {
    throw new Error("Invalid input: Price and discount percentage must be non-negative, and discount percentage must be between 0 and 100.");
  }
  return price * (discountPercentage / 100);
}

            

              
                Copy
              
            
          

Lūk, kā jūs varat uzrakstīt vienības testu šai funkcijai, izmantojot Jest:

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

describe('calculateDiscount', () => {
  it('should calculate the discount amount correctly', () => {
    expect(calculateDiscount(100, 10)).toBe(10);
    expect(calculateDiscount(50, 20)).toBe(10);
    expect(calculateDiscount(200, 5)).toBe(10);
  });

  it('should handle zero discount percentage correctly', () => {
    expect(calculateDiscount(100, 0)).toBe(0);
  });

  it('should handle 100% discount correctly', () => {
    expect(calculateDiscount(100, 100)).toBe(100);
  });

  it('should throw an error for invalid input (negative price)', () => {
    expect(() => calculateDiscount(-100, 10)).toThrowError("Invalid input: Price and discount percentage must be non-negative, and discount percentage must be between 0 and 100.");
  });

  it('should throw an error for invalid input (negative discount percentage)', () => {
    expect(() => calculateDiscount(100, -10)).toThrowError("Invalid input: Price and discount percentage must be non-negative, and discount percentage must be between 0 and 100.");
  });

  it('should throw an error for invalid input (discount percentage > 100)', () => {
    expect(() => calculateDiscount(100, 110)).toThrowError("Invalid input: Price and discount percentage must be non-negative, and discount percentage must be between 0 and 100.");
  });
});

            

              
                Copy
              
            
          

Šis piemērs parāda, kā TypeScript tipu sistēma palīdz nodrošināt, ka funkcijai tiek nodoti pareizi datu tipi un ka testi aptver dažādus scenārijus, ieskaitot robežgadījumus un kļūdu apstākļus.

TypeScript Tipu Izmantošana Vienību Testos

TypeScript tipu sistēmu var izmantot, lai uzlabotu vienību testu skaidrību un uzturamību. Piemēram, jūs varat izmantot saskarnes, lai definētu funkciju atgriezto objektu paredzamo struktūru:

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

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

it('should return a user object with the correct properties', () => {
  const user = getUser(123);
  expect(user.id).toBe(123);
  expect(user.name).toBe('John Doe');
  expect(user.email).toBe('john.doe@example.com');
});

            

              
                Copy
              
            
          

Izmantojot `User` saskarni, jūs nodrošināt, ka tests pārbauda pareizus rekvizītus un tipus, padarot to robustāku un mazāk pakļautu kļūdām.

Maketēšana un Aizstāšana ar TypeScript

Apsveriet funkciju, kas paļaujas uz ārējo pakalpojumu, lai iegūtu datus:

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

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

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

            

              
                Copy
              
            
          

Lai testētu `MyComponent`, varat izveidot `DataService` maketa implementāciju:

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

it('should fetch data from the data service', async () => {
  const mockDataService = new MockDataService();
  const component = new MyComponent(mockDataService);
  const data = await component.fetchData(123);
  expect(data).toBe('Data for id 123');
});

            

              
                Copy
              
            
          

Implementējot `DataService` saskarni, `MockDataService` nodrošina, ka tā nodrošina nepieciešamās metodes ar pareiziem tipiem, novēršot ar tipiem saistītas kļūdas testēšanas laikā.

Integrācijas Testēšana TypeScript: Moduļu Mijiedarbības Pārbaude

Integrācijas testēšana koncentrējas uz dažādu vienību vai moduļu mijiedarbības pārbaudi lietojumprogrammā. Šis testēšanas līmenis ir ļoti svarīgs, lai nodrošinātu, ka dažādas sistēmas daļas darbojas kopā pareizi.

Piemērs: Integrācijas Testēšana ar Datu bāzi

• Testa datu bāzes iestatīšana.
• Datu bāzes aizpildīšana ar testa datiem.
• Lietojumprogrammas koda izpilde, kas mijiedarbojas ar datu bāzi.
• Pārbaude, vai dati ir pareizi saglabāti un izgūti.
• Testa datu bāzes notīrīšana pēc testa pabeigšanas.

            // 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'); // Use a separate test database
    await databaseConnection.connect();
    userRepository = new UserRepository(databaseConnection);
  });

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

  beforeEach(async () => {
    // Clear the database before each test
    await databaseConnection.clearDatabase();
  });

  it('should create a new user in the database', 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('should retrieve a user from the database by ID', 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
              
            
          

Šis piemērs parāda, kā iestatīt testa vidi, mijiedarboties ar datu bāzi un pārbaudīt, vai lietojumprogrammas kods pareizi saglabā un izgūst datus. TypeScript saskarņu izmantošana datu bāzes entītijām (piemēram, `User`) nodrošina tipdrošību visā integrācijas testēšanas procesā.

Ārējo Pakalpojumu Maketēšana Integrācijas Testos

Integrācijas testos bieži ir nepieciešams maketēt ārējos pakalpojumus, no kuriem ir atkarīga lietojumprogramma. Tas ļauj pārbaudīt integrāciju starp lietojumprogrammu un pakalpojumu, faktiski nepaļaujoties uz pašu pakalpojumu.

Piemēram, ja jūsu lietojumprogramma ir integrēta ar maksājumu vārteju, varat izveidot vārtejas maketa implementāciju, lai simulētu dažādus maksājumu scenārijus.

Gala-līdz-galam (E2E) Testēšana TypeScript: Lietotāju Darbplūsmu Simulēšana

Gala-līdz-galam (E2E) testēšana ietver visas lietojumprogrammas darbplūsmas testēšanu no lietotāja perspektīvas. Šis testēšanas veids ir ļoti svarīgs, lai nodrošinātu, ka lietojumprogramma darbojas pareizi reālajā vidē.

E2E Testēšanas Ietvara Izvēle

TypeScript ir pieejami vairāki populāri E2E testēšanas ietvari, tostarp:

• Cypress: Jaudīgs un lietotājam draudzīgs E2E testēšanas ietvars, kas ļauj rakstīt testus, kas simulē lietotāju mijiedarbību ar lietojumprogrammu.
• Playwright: Pārlūkprogrammu testēšanas ietvars, kas atbalsta vairākas programmēšanas valodas, tostarp TypeScript.
• Puppeteer: Node bibliotēka, kas nodrošina augsta līmeņa API, lai kontrolētu bezgalvas Chrome vai Chromium.

Cypress ir īpaši piemērots tīmekļa lietojumprogrammu E2E testēšanai tā lietošanas vienkāršības un visaptverošo funkciju dēļ. Playwright ir lielisks pārlūkprogrammu saderībai un uzlabotām funkcijām. Mēs demonstrēsim E2E testēšanas koncepcijas, izmantojot Cypress.

Piemērs: E2E Testēšana ar Cypress

Apsveriet vienkāršu tīmekļa lietojumprogrammu ar pieteikšanās veidlapu. Šīs lietojumprogrammas E2E tests varētu ietvert:

• Pieteikšanās lapas apmeklēšana.
• Derīgu akreditācijas datu ievadīšana.
• Veidlapas iesniegšana.
• Pārbaude, vai lietotājs tiek novirzīts uz sākumlapu.

            // cypress/integration/login.spec.ts
describe('Login', () => {
  it('should log in successfully with valid credentials', () => {
    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('should display an error message with invalid credentials', () => {
    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
              
            
          

Šis piemērs parāda, kā izmantot Cypress, lai simulētu lietotāju mijiedarbību ar tīmekļa lietojumprogrammu un pārbaudītu, vai lietojumprogramma darbojas, kā paredzēts. Cypress nodrošina jaudīgu API mijiedarbībai ar DOM, apgalvojumu izteikšanai un lietotāju notikumu simulēšanai.

Tipdrošība Cypress Testos

Lai gan Cypress galvenokārt ir uz JavaScript balstīts ietvars, jūs joprojām varat izmantot TypeScript, lai uzlabotu E2E testu tipdrošību. Piemēram, varat izmantot TypeScript, lai definētu pielāgotas komandas un ierakstītu API zvanu atgrieztos datus.

Labākā Prakse TypeScript Testēšanai

Lai nodrošinātu, ka jūsu TypeScript testi ir efektīvi un viegli uzturami, apsveriet šādu labāko praksi:

• Rakstiet Testus Agri un Bieži: Integrējiet testēšanu savā izstrādes darbplūsmā no paša sākuma. Uz testiem balstīta izstrāde (TDD) ir lieliska pieeja.
• Koncentrējieties uz Testējamību: Izstrādājiet savu kodu tā, lai to būtu viegli testēt. Izmantojiet atkarību injekciju, lai atdalītu komponentus un padarītu tos vieglāk maketējamus.
• Saglabājiet Testus Mazus un Koncentrētus: Katram testam jākoncentrējas uz vienu koda aspektu. Tas atvieglo testu saprašanu un uzturēšanu.
• Izmantojiet Aprakstošus Testu Nosaukumus: Izvēlieties testu nosaukumus, kas skaidri apraksta, ko tests pārbauda.
• Uzturiet Augstu Testu Pārklājuma Līmeni: Tiecieties uz augstu testu pārklājumu, lai nodrošinātu, ka visas koda daļas ir atbilstoši testētas.
• Automatizējiet Savus Testus: Integrējiet savus testus nepārtrauktas integrācijas (CI) cauruļvadā, lai automātiski palaistu testus, kad tiek veiktas koda izmaiņas.
• Izmantojiet Koda Pārklājuma Rīkus: Izmantojiet rīkus, lai mērītu testu pārklājumu un identificētu koda apgabalus, kas nav atbilstoši testēti.
• Regulāri Refaktorējiet Testus: Kad jūsu kods mainās, refaktorējiet savus testus, lai tie būtu atjaunināti un viegli uzturami.
• Dokumentējiet Savus Testus: Pievienojiet komentārus saviem testiem, lai izskaidrotu testa mērķi un visus pieņēmumus, ko tas pieņem.
• Ievērojiet AAA Paraugu: Sakārtojiet, Rīkojieties, Apstipriniet. Tas palīdz strukturēt jūsu testus lasāmībai.

Secinājums: Robustu Lietojumprogrammu Izveide ar Tipdrošu TypeScript Testēšanu

TypeScript spēcīgā tipu sistēma nodrošina jaudīgu pamatu robustu un viegli uzturamu lietojumprogrammu izveidei. Izmantojot tipdrošību savās testēšanas stratēģijās, jūs varat izveidot uzticamākus un efektīvākus testus, kas savlaicīgi uztver kļūdas un uzlabo jūsu koda vispārējo kvalitāti. Šajā rakstā ir aplūkotas dažādas TypeScript testēšanas stratēģijas, sākot no vienību testēšanas līdz integrācijas testēšanai un gala-līdz-galam testēšanai, sniedzot jums visaptverošu ceļvedi TypeScript testēšanai. Ievērojot šajā rakstā izklāstīto labāko praksi, jūs varat nodrošināt, ka jūsu TypeScript lietojumprogrammas ir rūpīgi testētas un gatavas ražošanai. Visaptverošas testēšanas pieejas pieņemšana no paša sākuma ļauj izstrādātājiem visā pasaulē izveidot uzticamāku un vieglāk uzturamu programmatūru, kas nodrošina uzlabotu lietotāju pieredzi un samazina izstrādes izmaksas. Turpinoties TypeScript ieviešanai, tipdrošas testēšanas apgūšana kļūst par arvien vērtīgāku prasmi programmatūras inženieriem visā pasaulē.