Pengujian JavaScript ialah aspek penting dalam pembangunan perisian yang memastikan kebolehpercayaan dan keteguhan kod kami. Sebagai pembangun, saya mendapati bahawa melaksanakan strategi ujian komprehensif bukan sahaja menangkap pepijat lebih awal tetapi juga meningkatkan kualiti keseluruhan aplikasi saya. Mari terokai lima teknik ujian JavaScript penting yang terbukti tidak ternilai dalam pengalaman saya.

Ujian unit membentuk asas kepada mana-mana strategi ujian yang kukuh. Ia melibatkan ujian fungsi individu, kaedah dan komponen secara berasingan untuk mengesahkan bahawa ia berkelakuan seperti yang diharapkan. Saya sering menggunakan Jest, rangka kerja ujian JavaScript yang popular, untuk menulis dan menjalankan ujian unit. Berikut ialah contoh ujian unit mudah menggunakan Jest:

function add(a, b) {
  return a + b;
}

test('add function correctly adds two numbers', () => {
  expect(add(2, 3)).toBe(5);
  expect(add(-1, 1)).toBe(0);
  expect(add(0, 0)).toBe(0);
});

Dalam contoh ini, kami sedang menguji fungsi tambahan asas untuk memastikan ia menghasilkan hasil yang betul untuk pelbagai input. Ujian unit seperti ini membantu kami menangkap ralat dalam bahagian fungsi individu dan menjadikannya lebih mudah untuk memfaktorkan semula kod dengan yakin.

Melangkaui unit individu, ujian integrasi meneliti cara bahagian aplikasi kami yang berbeza berfungsi bersama. Teknik ini mengesahkan bahawa komponen berinteraksi dengan betul dan data mengalir dengan betul antara mereka. Sebagai contoh, kami mungkin menguji cara modul pengesahan pengguna disepadukan dengan lapisan akses pangkalan data. Berikut ialah contoh ujian penyepaduan menggunakan Jest dan pangkalan data olok-olok:

const UserAuth = require('./userAuth');
const mockDatabase = require('./mockDatabase');

jest.mock('./database', () => mockDatabase);

describe('User Authentication', () => {
  test('successfully authenticates a valid user', async () => {
    const userAuth = new UserAuth();
    const result = await userAuth.authenticate('validuser', 'correctpassword');
    expect(result).toBe(true);
  });

  test('fails to authenticate an invalid user', async () => {
    const userAuth = new UserAuth();
    const result = await userAuth.authenticate('invaliduser', 'wrongpassword');
    expect(result).toBe(false);
  });
});

Dalam ujian penyepaduan ini, kami sedang mengesahkan bahawa modul UserAuth kami berinteraksi dengan betul dengan pangkalan data untuk mengesahkan pengguna. Dengan menggunakan pangkalan data palsu, kami boleh mengawal persekitaran ujian dan menumpukan pada penyepaduan antara komponen ini.

Ujian hujung ke hujung (E2E) mengambil pendekatan holistik dengan mensimulasikan interaksi pengguna sebenar dengan aplikasi kami. Teknik ini membantu kami menangkap isu yang mungkin hanya timbul apabila semua bahagian sistem berfungsi bersama. Saya sering menggunakan Cypress, rangka kerja ujian E2E yang berkuasa, untuk tujuan ini. Berikut ialah contoh ujian Cypress untuk borang log masuk:

describe('Login Form', () => {
  it('successfully logs in a user', () => {
    cy.visit('/login');
    cy.get('input[name="username"]').type('testuser');
    cy.get('input[name="password"]').type('testpassword');
    cy.get('button[type="submit"]').click();
    cy.url().should('include', '/dashboard');
    cy.contains('Welcome, Test User').should('be.visible');
  });
});

Ujian E2E ini mengautomasikan proses menavigasi ke halaman log masuk, memasukkan bukti kelayakan, menyerahkan borang dan mengesahkan bahawa pengguna berjaya log masuk dan diubah hala ke papan pemuka. Ujian sedemikian amat berharga untuk memastikan aplikasi kami berfungsi dengan betul dari perspektif pengguna.

Mengejek dan menegur ialah teknik yang sering saya gunakan untuk mengasingkan kod yang sedang diuji dan mengawal tingkah laku kebergantungan luaran. Pendekatan ini amat berguna apabila berurusan dengan API, pangkalan data atau sistem kompleks lain. Berikut ialah contoh menggunakan Jest untuk mengejek panggilan API:

function add(a, b) {
  return a + b;
}

test('add function correctly adds two numbers', () => {
  expect(add(2, 3)).toBe(5);
  expect(add(-1, 1)).toBe(0);
  expect(add(0, 0)).toBe(0);
});

Dalam contoh ini, kami mengejek perpustakaan axios untuk mengembalikan objek pengguna yang dipratentukan dan bukannya membuat panggilan API sebenar. Ini membolehkan kami menguji fungsi fetchUserData kami secara berasingan, tanpa bergantung pada ketersediaan atau keadaan API luaran.

Liputan kod ialah metrik yang membantu kami memahami berapa banyak asas kod kami digunakan oleh ujian kami. Walaupun liputan 100% tidak menjamin kod bebas pepijat, ia merupakan penunjuk berguna bagi kawasan yang mungkin memerlukan ujian tambahan. Saya menggunakan Istanbul, alat liputan kod yang disepadukan dengan baik dengan Jest, untuk menjana laporan liputan. Begini cara anda boleh mengkonfigurasi Jest untuk menggunakan Istanbul:

const UserAuth = require('./userAuth');
const mockDatabase = require('./mockDatabase');

jest.mock('./database', () => mockDatabase);

describe('User Authentication', () => {
  test('successfully authenticates a valid user', async () => {
    const userAuth = new UserAuth();
    const result = await userAuth.authenticate('validuser', 'correctpassword');
    expect(result).toBe(true);
  });

  test('fails to authenticate an invalid user', async () => {
    const userAuth = new UserAuth();
    const result = await userAuth.authenticate('invaliduser', 'wrongpassword');
    expect(result).toBe(false);
  });
});

Konfigurasi ini memberitahu Jest untuk mengumpulkan maklumat liputan, menjana laporan dalam kedua-dua format teks dan lcov serta menguatkuasakan ambang liputan minimum sebanyak 80% merentas pelbagai metrik.

Melaksanakan teknik ujian ini telah meningkatkan kualiti dan kebolehpercayaan aplikasi JavaScript saya dengan ketara. Walau bagaimanapun, adalah penting untuk diingat bahawa ujian adalah proses yang berterusan. Apabila pangkalan kod kami berkembang, begitu juga ujian kami. Menyemak dan mengemas kini suite ujian kami dengan kerap memastikan ia kekal berkesan dalam menangkap pepijat dan regresi.

Satu amalan yang saya dapati amat berguna ialah pembangunan dipacu ujian (TDD). Dengan TDD, kami menulis ujian sebelum melaksanakan fungsi sebenar. Pendekatan ini membantu menjelaskan keperluan, membimbing reka bentuk kod kami dan memastikan setiap bahagian fungsi mempunyai ujian yang sepadan. Berikut ialah contoh cara saya menggunakan TDD untuk melaksanakan fungsi kalkulator mudah:

describe('Login Form', () => {
  it('successfully logs in a user', () => {
    cy.visit('/login');
    cy.get('input[name="username"]').type('testuser');
    cy.get('input[name="password"]').type('testpassword');
    cy.get('button[type="submit"]').click();
    cy.url().should('include', '/dashboard');
    cy.contains('Welcome, Test User').should('be.visible');
  });
});

Dalam contoh TDD ini, kami mula-mula menulis ujian untuk setiap operasi kalkulator, termasuk kes tepi seperti pembahagian dengan sifar. Kemudian, kami melaksanakan kelas Kalkulator untuk membuat ujian ini lulus. Pendekatan ini memastikan kod kami memenuhi keperluan yang ditetapkan dan mempunyai liputan ujian yang komprehensif dari awal.

Satu lagi aspek penting dalam ujian JavaScript ialah mengendalikan kod tak segerak. Banyak operasi dalam JavaScript, seperti panggilan API atau pertanyaan pangkalan data, adalah tidak segerak. Jest menyediakan beberapa cara untuk menguji kod tak segerak dengan berkesan. Berikut ialah contoh menguji fungsi tak segerak:

const axios = require('axios');
jest.mock('axios');

const fetchUserData = async (userId) => {
  const response = await axios.get(`https://api.example.com/users/${userId}`);
  return response.data;
};

test('fetchUserData retrieves user information', async () => {
  const mockUser = { id: 1, name: 'John Doe', email: 'john@example.com' };
  axios.get.mockResolvedValue({ data: mockUser });

  const userData = await fetchUserData(1);
  expect(userData).toEqual(mockUser);
  expect(axios.get).toHaveBeenCalledWith('https://api.example.com/users/1');
});

Dalam ujian ini, kami menggunakan fungsi async dan kata kunci tunggu untuk mengendalikan operasi fetchData tak segerak. Jest secara automatik menunggu janji diselesaikan sebelum menyelesaikan ujian.

Apabila aplikasi kami berkembang dalam kerumitan, kami selalunya perlu menguji komponen yang mempunyai keadaan dalaman atau bergantung pada konteks luaran. Untuk aplikasi React, saya menggunakan Pustaka Pengujian React, yang menggalakkan pengujian komponen dengan cara yang menyerupai cara pengguna berinteraksi dengannya. Berikut ialah contoh menguji komponen pembilang mudah:

function add(a, b) {
  return a + b;
}

test('add function correctly adds two numbers', () => {
  expect(add(2, 3)).toBe(5);
  expect(add(-1, 1)).toBe(0);
  expect(add(0, 0)).toBe(0);
});

Ujian ini memaparkan komponen Kaunter, mensimulasikan interaksi pengguna dengan mengklik pada butang dan mengesahkan bahawa kiraan yang dipaparkan berubah dengan betul.

Ujian prestasi ialah satu lagi aspek penting untuk memastikan aplikasi JavaScript kami berjalan lancar. Walaupun tidak selalunya boleh dilaksanakan untuk memasukkan ujian prestasi dalam suite ujian biasa kami kerana masa pelaksanaannya yang berpotensi panjang, kami boleh mencipta suite ujian prestasi yang berasingan. Berikut ialah contoh menggunakan perpustakaan Benchmark.js untuk membandingkan prestasi algoritma pengisihan tatasusunan yang berbeza:

const UserAuth = require('./userAuth');
const mockDatabase = require('./mockDatabase');

jest.mock('./database', () => mockDatabase);

describe('User Authentication', () => {
  test('successfully authenticates a valid user', async () => {
    const userAuth = new UserAuth();
    const result = await userAuth.authenticate('validuser', 'correctpassword');
    expect(result).toBe(true);
  });

  test('fails to authenticate an invalid user', async () => {
    const userAuth = new UserAuth();
    const result = await userAuth.authenticate('invaliduser', 'wrongpassword');
    expect(result).toBe(false);
  });
});

Ujian prestasi ini membandingkan kelajuan pelaksanaan isihan gelembung dan algoritma isihan pantas, membantu kami membuat keputusan termaklum tentang algoritma yang hendak digunakan dalam aplikasi kami.

Sambil kami membangunkan aplikasi yang lebih kompleks, kami selalunya perlu menguji cara kod kami berkelakuan dalam pelbagai keadaan atau dengan input yang berbeza. Ujian berasaskan harta ialah teknik yang menjana input rawak untuk ujian kami, membantu kami menemui kes kelebihan dan gelagat yang tidak dijangka. Fast-check ialah perpustakaan popular untuk ujian berasaskan harta dalam JavaScript. Berikut ialah contoh:

describe('Login Form', () => {
  it('successfully logs in a user', () => {
    cy.visit('/login');
    cy.get('input[name="username"]').type('testuser');
    cy.get('input[name="password"]').type('testpassword');
    cy.get('button[type="submit"]').click();
    cy.url().should('include', '/dashboard');
    cy.contains('Welcome, Test User').should('be.visible');
  });
});

Dalam ujian ini, semakan pantas menjana integer rawak dan mengesahkan bahawa fungsi abs kami berfungsi dengan betul untuk semua input.

Apabila suite ujian kami berkembang, adalah penting untuk memastikan ia teratur dan boleh diselenggara. Satu teknik yang saya dapati membantu ialah mengumpulkan ujian berkaitan dengan menggunakan huraikan blok dan gunakan sebelumEach dan afterEach cangkuk untuk menyediakan dan meruntuhkan persekitaran ujian. Pendekatan ini memastikan ujian kami bersih dan mengurangkan pertindihan. Berikut ialah contoh:

const axios = require('axios');
jest.mock('axios');

const fetchUserData = async (userId) => {
  const response = await axios.get(`https://api.example.com/users/${userId}`);
  return response.data;
};

test('fetchUserData retrieves user information', async () => {
  const mockUser = { id: 1, name: 'John Doe', email: 'john@example.com' };
  axios.get.mockResolvedValue({ data: mockUser });

  const userData = await fetchUserData(1);
  expect(userData).toEqual(mockUser);
  expect(axios.get).toHaveBeenCalledWith('https://api.example.com/users/1');
});

Pendekatan berstruktur ini menjadikan ujian kami lebih mudah dibaca dan lebih mudah diselenggara apabila aplikasi kami berkembang.

Kesimpulannya, melaksanakan teknik ujian JavaScript ini telah meningkatkan kualiti dan kebolehpercayaan kod saya dengan ketara. Daripada ujian unit yang mengesahkan fungsi individu kepada ujian hujung ke hujung yang mensimulasikan interaksi pengguna, setiap teknik memainkan peranan penting dalam mencipta aplikasi yang mantap. Dengan menggabungkan ejekan, analisis liputan kod dan teknik lanjutan seperti ujian berasaskan harta, kami boleh menangkap pelbagai isu sebelum ia mencapai pengeluaran. Ingat, ujian berkesan ialah proses berterusan yang berkembang dengan pangkalan kod kami. Dengan menggunakan teknik ini secara konsisten dan menyesuaikan strategi ujian kami mengikut keperluan, kami boleh membina aplikasi JavaScript yang lebih dipercayai, boleh diselenggara dan berkualiti tinggi.

Ciptaan Kami

Pastikan anda melihat ciptaan kami:

Pusat Pelabur | Hidup Pintar | Epos & Gema | Misteri Membingungkan | Hindutva | Pembangunan Elit | Sekolah JS

Kami berada di Medium

Tech Koala Insights | Dunia Epok & Gema | Medium Pusat Pelabur | Medium Misteri Membingungkan | Sains & Zaman Sederhana | Hindutva Moden

Atas ialah kandungan terperinci Teknik Pengujian JavaScript yang penting untuk Kod Teguh. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!