जेस्ट: मजबूत सॉफ्टवेअरसाठी प्रगत टेस्टिंग पॅटर्न्स

आजच्या वेगवान सॉफ्टवेअर डेव्हलपमेंटच्या जगात, तुमच्या कोडबेसची विश्वसनीयता आणि स्थिरता सुनिश्चित करणे अत्यंत महत्त्वाचे आहे. जेस्ट हे जावास्क्रिप्ट टेस्टिंगसाठी एक मानक बनले असले तरी, मूलभूत युनिट टेस्टच्या पलीकडे जाऊन तुमच्या ॲप्लिकेशन्समध्ये आत्मविश्वासाची एक नवीन पातळी उघडते. हे पोस्ट प्रगत जेस्ट टेस्टिंग पॅटर्न्सवर लक्ष केंद्रित करते जे जागतिक स्तरावरील डेव्हलपर्ससाठी मजबूत सॉफ्टवेअर तयार करण्यासाठी आवश्यक आहेत.

मूलभूत युनिट टेस्टच्या पलीकडे का जावे?

मूलभूत युनिट टेस्ट स्वतंत्र घटकांची एकटेपणाने पडताळणी करतात. तथापि, वास्तविक जगातील ॲप्लिकेशन्स ही गुंतागुंतीची प्रणाली असते जिथे घटक एकमेकांशी संवाद साधतात. प्रगत टेस्टिंग पॅटर्न्स या गुंतागुंतींना हाताळतात, ज्यामुळे आम्हाला हे शक्य होते:

गुंतागुंतीच्या डिपेंडेंसीजचे अनुकरण करणे.
UI मधील बदल विश्वसनीयतेने कॅप्चर करणे.
अधिक प्रभावी आणि सुलभ टेस्ट लिहिणे.
टेस्ट कव्हरेज आणि इंटिग्रेशन पॉइंट्समधील आत्मविश्वास सुधारणे.
टेस्ट-ड्रिव्हन डेव्हलपमेंट (TDD) आणि बिहेवियर-ड्रिव्हन डेव्हलपमेंट (BDD) वर्कफ्लो सुलभ करणे.

मॉकिंग आणि स्पाईजमध्ये प्राविण्य

टेस्ट केल्या जाणार्‍या युनिटला त्याच्या डिपेंडेंसीजना नियंत्रित पर्यायांसह बदलून वेगळे करण्यासाठी मॉकिंग महत्त्वाचे आहे. जेस्ट यासाठी शक्तिशाली साधने प्रदान करते:

`jest.fn()`: मॉक्स आणि स्पाईजचा पाया

jest.fn() एक मॉक फंक्शन तयार करते. तुम्ही त्याचे कॉल्स, आर्ग्युमेंट्स आणि रिटर्न व्हॅल्यूज ट्रॅक करू शकता. अधिक अत्याधुनिक मॉकिंग स्ट्रॅटेजीसाठी हा एक बिल्डिंग ब्लॉक आहे.

उदाहरण: फंक्शन कॉल्स ट्रॅक करणे

// component.js
export const fetchData = () => {
  // API कॉलचे अनुकरण करते
  return Promise.resolve({ data: 'some data' });
};

export const processData = async (fetcher) => {
  const result = await fetcher();
  return `Processed: ${result.data}`;
};

// component.test.js
import { processData } from './component';

test('should process data correctly', async () => {
  const mockFetcher = jest.fn().mockResolvedValue({ data: 'mocked data' });
  const result = await processData(mockFetcher);
  expect(result).toBe('Processed: mocked data');
  expect(mockFetcher).toHaveBeenCalledTimes(1);
  expect(mockFetcher).toHaveBeenCalledWith();
});

`jest.spyOn()`: न बदलता निरीक्षण करणे

jest.spyOn() तुम्हाला विद्यमान ऑब्जेक्टवरील मेथडच्या कॉल्सचे निरीक्षण करण्याची परवानगी देते, त्याच्या अंमलबजावणीला बदलण्याची गरज नाही. आवश्यक असल्यास तुम्ही अंमलबजावणी मॉक देखील करू शकता.

उदाहरण: मॉड्यूल मेथडवर हेरगिरी करणे (स्पायिंग)

// logger.js
export const logInfo = (message) => {
  console.log(`INFO: ${message}`);
};

// service.js
import { logInfo } from './logger';

export const performTask = (taskName) => {
  logInfo(`Starting task: ${taskName}`);
  // ... task logic ...
  logInfo(`Task ${taskName} completed.`);
};

// service.test.js
import { performTask } from './service';
import * as logger from './logger';

test('should log task start and completion', () => {
  const logSpy = jest.spyOn(logger, 'logInfo');

  performTask('backup');

  expect(logSpy).toHaveBeenCalledTimes(2);
  expect(logSpy).toHaveBeenCalledWith('Starting task: backup');
  expect(logSpy).toHaveBeenCalledWith('Task backup completed.');

  logSpy.mockRestore(); // मूळ अंमलबजावणी पुनर्संचयित करणे महत्त्वाचे आहे
});

मॉड्यूल इम्पोर्ट्सचे मॉकिंग

जेस्टची मॉड्यूल मॉकिंग क्षमता विस्तृत आहे. तुम्ही संपूर्ण मॉड्यूल किंवा विशिष्ट एक्सपोर्ट्स मॉक करू शकता.

उदाहरण: बाह्य API क्लायंटचे मॉकिंग

// api.js
import axios from 'axios';

export const getUser = async (userId) => {
  const response = await axios.get(`/api/users/${userId}`);
  return response.data;
};

// user-service.js
import { getUser } from './api';

export const getUserFullName = async (userId) => {
  const user = await getUser(userId);
  return `${user.firstName} ${user.lastName}`;
};

// user-service.test.js
import { getUserFullName } from './user-service';
import * as api from './api';

// संपूर्ण api मॉड्यूल मॉक करा
jest.mock('./api');

test('should get full name using mocked API', async () => {
  // मॉक केलेल्या मॉड्यूलमधून विशिष्ट फंक्शन मॉक करा
  api.getUser.mockResolvedValue({ id: 1, firstName: 'Ada', lastName: 'Lovelace' });

  const fullName = await getUserFullName(1);

  expect(fullName).toBe('Ada Lovelace');
  expect(api.getUser).toHaveBeenCalledTimes(1);
  expect(api.getUser).toHaveBeenCalledWith(1);
});

ऑटो-मॉकिंग विरुद्ध मॅन्युअल मॉकिंग

जेस्ट Node.js मॉड्यूल्सना आपोआप मॉक करते. ES मॉड्यूल्स किंवा कस्टम मॉड्यूल्ससाठी, तुम्हाला jest.mock() ची आवश्यकता असू शकते. अधिक नियंत्रणासाठी, तुम्ही __mocks__ डिरेक्टरीज तयार करू शकता.

मॉक इम्प्लिमेंटेशन्स (अंमलबजावणी)

तुम्ही तुमच्या मॉक्ससाठी कस्टम अंमलबजावणी प्रदान करू शकता.

उदाहरण: कस्टम अंमलबजावणीसह मॉकिंग

// math.js
export const add = (a, b) => a + b;
export const subtract = (a, b) => a - b;

// calculator.js
import { add, subtract } from './math';

export const calculate = (operation, a, b) => {
  if (operation === 'add') {
    return add(a, b);
  } else if (operation === 'subtract') {
    return subtract(a, b);
  }
  return null;
};

// calculator.test.js
import { calculate } from './calculator';
import * as math from './math';

// संपूर्ण math मॉड्यूल मॉक करा
jest.mock('./math');

test('should perform addition using mocked math add', () => {
  // 'add' फंक्शनसाठी मॉक अंमलबजावणी प्रदान करा
  math.add.mockImplementation((a, b) => a + b + 10); // परिणामामध्ये 10 जोडा
  math.subtract.mockReturnValue(5); // subtract ला देखील मॉक करा

  const result = calculate('add', 5, 3);

  expect(math.add).toHaveBeenCalledWith(5, 3);
  expect(result).toBe(18); // 5 + 3 + 10

  const subResult = calculate('subtract', 10, 2);
  expect(math.subtract).toHaveBeenCalledWith(10, 2);
  expect(subResult).toBe(5);
});

स्नॅपशॉट टेस्टिंग: UI आणि कॉन्फिगरेशन जतन करणे

स्नॅपशॉट टेस्ट तुमच्या कंपोनेंट्स किंवा कॉन्फिगरेशनच्या आउटपुटला कॅप्चर करण्यासाठी एक शक्तिशाली वैशिष्ट्य आहे. UI टेस्टिंग किंवा गुंतागुंतीच्या डेटा स्ट्रक्चर्सची पडताळणी करण्यासाठी ते विशेषतः उपयुक्त आहेत.

स्नॅपशॉट टेस्टिंग कसे कार्य करते

जेव्हा स्नॅपशॉट टेस्ट पहिल्यांदा चालते, तेव्हा जेस्ट एक .snap फाईल तयार करते ज्यामध्ये टेस्ट केलेल्या व्हॅल्यूचे सिरीयलाइज्ड रिप्रेझेंटेशन असते. त्यानंतरच्या रनमध्ये, जेस्ट सध्याच्या आउटपुटची संग्रहित स्नॅपशॉटशी तुलना करते. जर ते भिन्न असतील, तर टेस्ट अयशस्वी होते, ज्यामुळे तुम्हाला अनपेक्षित बदलांबद्दल सतर्क केले जाते. विविध प्रदेश किंवा लोकेलमध्ये UI घटकांमधील रिग्रेशन शोधण्यासाठी हे अमूल्य आहे.

उदाहरण: React कंपोनेंटचे स्नॅपशॉटिंग

समजा तुमच्याकडे React कंपोनेंट आहे:

// UserProfile.js
import React from 'react';

const UserProfile = ({ name, email, isActive }) => (
  <div>
    <h2>{name}</h2>
    <p><strong>Email:</strong> {email}</p>
    <p><strong>Status:</strong> {isActive ? 'Active' : 'Inactive'}</p>
  </div>
);

export default UserProfile;

// UserProfile.test.js
import React from 'react';
import renderer from 'react-test-renderer'; // React कंपोनेंट स्नॅपशॉटसाठी
import UserProfile from './UserProfile';

test('renders UserProfile correctly', () => {
  const user = {
    name: 'Jane Doe',
    email: 'jane.doe@example.com',
    isActive: true,
  };
  const component = renderer.create(
    <UserProfile {...user} />
  );
  const tree = component.toJSON();
  expect(tree).toMatchSnapshot();
});

test('renders inactive UserProfile correctly', () => {
  const user = {
    name: 'John Smith',
    email: 'john.smith@example.com',
    isActive: false,
  };
  const component = renderer.create(
    <UserProfile {...user} />
  );
  const tree = component.toJSON();
  expect(tree).toMatchSnapshot('inactive user profile'); // नावाचा स्नॅपशॉट
});

टेस्ट चालवल्यानंतर, जेस्ट एक UserProfile.test.js.snap फाईल तयार करेल. जेव्हा तुम्ही कंपोनेंट अपडेट करता, तेव्हा तुम्हाला बदलांचे पुनरावलोकन करावे लागेल आणि शक्यतो --updateSnapshot किंवा -u फ्लॅगसह जेस्ट चालवून स्नॅपशॉट अपडेट करावा लागेल.

स्नॅपशॉट टेस्टिंगसाठी सर्वोत्तम पद्धती

UI कंपोनेंट्स आणि कॉन्फिगरेशन फाइल्ससाठी वापरा: UI घटक अपेक्षेप्रमाणे रेंडर होतात आणि कॉन्फिगरेशन अनपेक्षितपणे बदलत नाही याची खात्री करण्यासाठी आदर्श.
स्नॅपशॉट्सचे काळजीपूर्वक पुनरावलोकन करा: स्नॅपशॉट अपडेट्स स्वीकारताना घाई करू नका. बदल हेतुपुरस्सर आहेत याची खात्री करण्यासाठी नेहमी काय बदलले आहे याचे पुनरावलोकन करा.
वारंवार बदलणाऱ्या डेटासाठी स्नॅपशॉट टाळा: जर डेटा वेगाने बदलत असेल, तर स्नॅपशॉट नाजूक होऊ शकतात आणि अनावश्यक गोंधळ निर्माण करू शकतात.
नावाचे स्नॅपशॉट वापरा: कंपोनेंटच्या अनेक स्थितींची चाचणी घेण्यासाठी, नावाचे स्नॅपशॉट अधिक स्पष्टता प्रदान करतात.

कस्टम मॅचर्स: टेस्टची वाचनीयता वाढवणे

जेस्टचे अंगभूत मॅचर्स विस्तृत आहेत, परंतु कधीकधी तुम्हाला विशिष्ट अटींची पडताळणी करावी लागते ज्या समाविष्ट नाहीत. कस्टम मॅचर्स तुम्हाला स्वतःचा ॲसर्शन लॉजिक तयार करण्याची परवानगी देतात, ज्यामुळे तुमच्या टेस्ट अधिक प्रभावी आणि वाचनीय बनतात.

कस्टम मॅचर्स तयार करणे

तुम्ही जेस्टच्या expect ऑब्जेक्टला तुमच्या स्वतःच्या मॅचर्ससह विस्तारित करू शकता.

उदाहरण: वैध ईमेल फॉरमॅट तपासणे

तुमच्या जेस्ट सेटअप फाईलमध्ये (उदा. jest.setup.js, jest.config.js मध्ये कॉन्फिगर केलेले):

// jest.setup.js

expect.extend({
  toBeValidEmail(received) {
    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    const pass = emailRegex.test(received);

    if (pass) {
      return {
        message: () => `expected ${received} not to be a valid email`,
        pass: true,
      };
    } else {
      return {
        message: () => `expected ${received} to be a valid email`,
        pass: false,
      };
    }
  },
});

// तुमच्या jest.config.js मध्ये
// module.exports = { setupFilesAfterEnv: ['/jest.setup.js'] };

तुमच्या टेस्ट फाईलमध्ये:

// validation.test.js

test('should validate email formats', () => {
  expect('test@example.com').toBeValidEmail();
  expect('invalid-email').not.toBeValidEmail();
  expect('another.test@sub.domain.co.uk').toBeValidEmail();
});

कस्टम मॅचर्सचे फायदे

सुधारित वाचनीयता: टेस्ट अधिक वर्णनात्मक बनतात, *कसे* याऐवजी *काय* टेस्ट केले जात आहे हे सांगतात.
कोडचा पुनर्वापर: अनेक टेस्टमध्ये गुंतागुंतीचा ॲसर्शन लॉजिक पुन्हा लिहिणे टाळा.
डोमेन-विशिष्ट ॲसर्शन्स: तुमच्या ॲप्लिकेशनच्या विशिष्ट डोमेन आवश्यकतांनुसार ॲसर्शन्स तयार करा.

असિંक्रोनस ऑपरेशन्सची टेस्टिंग

जावास्क्रिप्ट मोठ्या प्रमाणावर असિંक्रोनस आहे. जेस्ट प्रॉमिसेस आणि async/await च्या टेस्टिंगसाठी उत्कृष्ट समर्थन पुरवते.

`async/await` वापरणे

असિંक्रोनस कोडची चाचणी करण्याचा हा आधुनिक आणि सर्वात वाचनीय मार्ग आहे.

उदाहरण: असિંक्रोनस फंक्शनची टेस्टिंग

// dataService.js
export const fetchUserData = async (userId) => {
  // विलंबानंतर डेटा आणण्याचे अनुकरण करा
  await new Promise(resolve => setTimeout(resolve, 50));
  if (userId === 1) {
    return { id: 1, name: 'Alice' };
  } else {
    throw new Error('User not found');
  }
};

// dataService.test.js
import { fetchUserData } from './dataService';

test('fetches user data correctly', async () => {
  const user = await fetchUserData(1);
  expect(user).toEqual({ id: 1, name: 'Alice' });
});

test('throws error for non-existent user', async () => {
  await expect(fetchUserData(2)).rejects.toThrow('User not found');
});

`.resolves` आणि `.rejects` वापरणे

हे मॅचर्स प्रॉमिस रिझोल्यूशन आणि रिजेक्शनची चाचणी सुलभ करतात.

उदाहरण: .resolves/.rejects वापरणे

// dataService.test.js (पुढे चालू)

test('fetches user data with .resolves', () => {
  return expect(fetchUserData(1)).resolves.toEqual({ id: 1, name: 'Alice' });
});

test('throws error for non-existent user with .rejects', () => {
  return expect(fetchUserData(2)).rejects.toThrow('User not found');
});

टायमर्स हाताळणे

setTimeout किंवा setInterval वापरणाऱ्या फंक्शन्ससाठी, जेस्ट टायमर नियंत्रण प्रदान करते.

उदाहरण: टायमर्स नियंत्रित करणे

// delayedGreeter.js
export const greetAfterDelay = (name, callback) => {
  setTimeout(() => {
    callback(`Hello, ${name}!`);
  }, 1000);
};

// delayedGreeter.test.js
import { greetAfterDelay } from './delayedGreeter';

jest.useFakeTimers(); // फेक टायमर्स सक्षम करा

test('greets after delay', () => {
  const mockCallback = jest.fn();
  greetAfterDelay('World', mockCallback);

  // टायमर्स 1000ms ने पुढे न्या
  jest.advanceTimersByTime(1000);

  expect(mockCallback).toHaveBeenCalledTimes(1);
  expect(mockCallback).toHaveBeenCalledWith('Hello, World!');
});

// इतरत्र आवश्यक असल्यास वास्तविक टायमर्स पुनर्संचयित करा
jest.useRealTimers();

टेस्टचे संघटन आणि रचना

तुमचा टेस्ट सूट जसजसा वाढत जातो, तसतसे देखभालीसाठी संघटन महत्त्वाचे ठरते.

डिस्क्राइब ब्लॉक्स आणि इट ब्लॉक्स

संबंधित टेस्ट्सना गटबद्ध करण्यासाठी describe वापरा आणि वैयक्तिक टेस्ट केसेससाठी it (किंवा test) वापरा. ही रचना ॲप्लिकेशनच्या मॉड्युलॅरिटीचे प्रतिबिंब आहे.

उदाहरण: संरचित टेस्ट्स

describe('User Authentication Service', () => {
  let authService;

  beforeEach(() => {
    // प्रत्येक टेस्टपूर्वी मॉक्स किंवा सर्व्हिस इन्स्टन्स सेटअप करा
    authService = require('./authService');
    jest.spyOn(authService, 'login').mockImplementation(() => Promise.resolve({ token: 'fake_token' }));
  });

  afterEach(() => {
    // मॉक्स स्वच्छ करा
    jest.restoreAllMocks();
  });

  describe('login functionality', () => {
    it('should successfully log in a user with valid credentials', async () => {
      const result = await authService.login('user@example.com', 'password123');
      expect(result.token).toBeDefined();
      // ... more assertions ...
    });

    it('should fail login with invalid credentials', async () => {
      jest.spyOn(authService, 'login').mockRejectedValue(new Error('Invalid credentials'));
      await expect(authService.login('user@example.com', 'wrong_password')).rejects.toThrow('Invalid credentials');
    });
  });

  describe('logout functionality', () => {
    it('should clear user session', async () => {
      // लॉगआउट लॉजिकची टेस्ट करा...
    });
  });
});

सेटअप आणि टियरडाउन हुक्स

beforeAll: describe ब्लॉकमधील सर्व टेस्ट्सच्या आधी एकदा चालते.
afterAll: describe ब्लॉकमधील सर्व टेस्ट्सच्या नंतर एकदा चालते.
beforeEach: describe ब्लॉकमधील प्रत्येक टेस्टच्या आधी चालते.
afterEach: describe ब्लॉकमधील प्रत्येक टेस्टच्या नंतर चालते.

हे हुक्स मॉक डेटा, डेटाबेस कनेक्शन्स सेट करण्यासाठी किंवा टेस्ट्स दरम्यान संसाधने स्वच्छ करण्यासाठी आवश्यक आहेत.

जागतिक प्रेक्षकांसाठी टेस्टिंग

जागतिक प्रेक्षकांसाठी ॲप्लिकेशन्स विकसित करताना, टेस्टिंगची व्याप्ती वाढते:

आंतरराष्ट्रीयीकरण (i18n) आणि स्थानिकीकरण (l10n)

तुमचे UI आणि संदेश वेगवेगळ्या भाषा आणि प्रादेशिक फॉरमॅट्सनुसार योग्यरित्या जुळवून घेतात याची खात्री करा.

स्थानिकीकृत UI चे स्नॅपशॉटिंग: तुमच्या UI च्या वेगवेगळ्या भाषांमधील आवृत्त्या स्नॅपशॉट टेस्ट वापरून योग्यरित्या रेंडर होतात की नाही हे तपासा.
लोकेल डेटाचे मॉकिंग: वेगवेगळ्या लोकेल संदेशांसह कंपोनेंटच्या वर्तनाची चाचणी घेण्यासाठी react-intl किंवा i18next सारख्या लायब्ररींना मॉक करा.
तारीख, वेळ आणि चलन फॉरमॅटिंग: हे कस्टम मॅचर्स वापरून किंवा आंतरराष्ट्रीयीकरण लायब्ररींना मॉक करून योग्यरित्या हाताळले जातात का ते तपासा. उदाहरणार्थ, जर्मनीसाठी फॉरमॅट केलेली तारीख (DD.MM.YYYY) ही यूएससाठी (MM/DD/YYYY) फॉरमॅट केलेल्या तारखेपेक्षा वेगळी दिसते याची पडताळणी करणे.

उदाहरण: स्थानिकीकृत तारीख फॉरमॅटिंगची टेस्टिंग

// dateUtils.js
export const formatLocalizedDate = (date, locale) => {
  return new Intl.DateTimeFormat(locale, { year: 'numeric', month: 'numeric', day: 'numeric' }).format(date);
};

// dateUtils.test.js
import { formatLocalizedDate } from './dateUtils';

test('formats date correctly for US locale', () => {
  const date = new Date(2023, 10, 15); // नोव्हेंबर १५, २०२३
  expect(formatLocalizedDate(date, 'en-US')).toBe('11/15/2023');
});

test('formats date correctly for German locale', () => {
  const date = new Date(2023, 10, 15);
  expect(formatLocalizedDate(date, 'de-DE')).toBe('15.11.2023');
});

टाइम झोन जागरूकता

तुमचा ॲप्लिकेशन वेगवेगळ्या टाइम झोनला कसा हाताळतो हे तपासा, विशेषतः शेड्युलिंग किंवा रिअल-टाइम अपडेट्ससारख्या वैशिष्ट्यांसाठी. सिस्टम क्लॉक मॉक करणे किंवा टाइम झोन अमूर्त करणाऱ्या लायब्ररी वापरणे फायदेशीर ठरू शकते.

डेटामधील सांस्कृतिक बारकावे

संख्या, चलन आणि इतर डेटा प्रस्तुतीकरण वेगवेगळ्या संस्कृतींमध्ये कसे पाहिले किंवा अपेक्षित केले जाऊ शकतात याचा विचार करा. कस्टम मॅचर्स येथे विशेषतः उपयुक्त ठरू शकतात.

प्रगत तंत्र आणि रणनीती

टेस्ट-ड्रिव्हन डेव्हलपमेंट (TDD) आणि बिहेवियर-ड्रिव्हन डेव्हलपमेंट (BDD)

जेस्ट TDD (रेड-ग्रीन-रिफॅक्टर) आणि BDD (गिव्हन-व्हेन-देन) पद्धतींशी चांगले जुळवून घेते. अंमलबजावणी कोड लिहिण्यापूर्वी इच्छित वर्तनाचे वर्णन करणाऱ्या टेस्ट लिहा. हे सुनिश्चित करते की कोड सुरुवातीपासूनच टेस्टेबिलिटी लक्षात घेऊन लिहिला जातो.

जेस्टसह इंटिग्रेशन टेस्टिंग

जेस्ट युनिट टेस्टसाठी उत्कृष्ट असले तरी, ते इंटिग्रेशन टेस्टसाठी देखील वापरले जाऊ शकते. कमी डिपेंडेंसीज मॉक करणे किंवा जेस्टच्या runInBand पर्यायासारखी साधने वापरणे मदत करू शकते.

उदाहरण: API संवादाची टेस्टिंग (सरलीकृत)

// apiService.js
import axios from 'axios';

const API_BASE_URL = 'https://api.example.com';

export const createProduct = async (productData) => {
  const response = await axios.post(`${API_BASE_URL}/products`, productData);
  return response.data;
};

// apiService.test.js (Integration test)
import axios from 'axios';
import { createProduct } from './apiService';

// नेटवर्क लेयर नियंत्रित करण्यासाठी इंटिग्रेशन टेस्टसाठी axios मॉक करा
jest.mock('axios');

test('creates a product via API', async () => {
  const mockProduct = { id: 1, name: 'Gadget' };
  const responseData = { success: true, product: mockProduct };

  axios.post.mockResolvedValue({
    data: responseData,
    status: 201,
    headers: { 'content-type': 'application/json' },
  });

  const newProductData = { name: 'Gadget', price: 99.99 };
  const result = await createProduct(newProductData);

  expect(axios.post).toHaveBeenCalledWith(`${process.env.API_BASE_URL || 'https://api.example.com'}/products`, newProductData);
  expect(result).toEqual(responseData);
});

समांतरता आणि कॉन्फिगरेशन

जेस्ट अंमलबजावणीला गती देण्यासाठी टेस्ट समांतरपणे चालवू शकते. हे तुमच्या jest.config.js मध्ये कॉन्फिगर करा. उदाहरणार्थ, maxWorkers सेट केल्याने समांतर प्रक्रियेची संख्या नियंत्रित होते.

कव्हरेज रिपोर्ट्स

तुमच्या कोडबेसचे कोणते भाग टेस्ट केले जात नाहीत हे ओळखण्यासाठी जेस्टच्या अंगभूत कव्हरेज रिपोर्टिंगचा वापर करा. तपशीलवार अहवाल तयार करण्यासाठी --coverage सह टेस्ट चालवा.

jest --coverage

कव्हरेज अहवालांचे पुनरावलोकन केल्याने हे सुनिश्चित होते की तुमचे प्रगत टेस्टिंग पॅटर्न्स आंतरराष्ट्रीयीकरण आणि स्थानिकीकरण कोड पाथसह महत्त्वाच्या लॉजिकला प्रभावीपणे कव्हर करत आहेत.

निष्कर्ष

प्रगत जेस्ट टेस्टिंग पॅटर्न्समध्ये प्राविण्य मिळवणे हे जागतिक प्रेक्षकांसाठी विश्वसनीय, देखरेख करण्यायोग्य आणि उच्च-गुणवत्तेचे सॉफ्टवेअर तयार करण्याच्या दिशेने एक महत्त्वाचे पाऊल आहे. मॉकिंग, स्नॅपशॉट टेस्टिंग, कस्टम मॅचर्स आणि असિંक्रोनस टेस्टिंग तंत्रांचा प्रभावीपणे वापर करून, तुम्ही तुमच्या टेस्ट सूटची मजबुती वाढवू शकता आणि विविध परिस्थिती आणि प्रदेशांमध्ये तुमच्या ॲप्लिकेशनच्या वर्तनाबद्दल अधिक आत्मविश्वास मिळवू शकता. या पॅटर्न्सचा अवलंब केल्याने जगभरातील डेव्हलपमेंट टीम्सना उत्कृष्ट वापरकर्ता अनुभव देण्यास सक्षम बनवते.

तुमच्या जावास्क्रिप्ट टेस्टिंग पद्धतींना उन्नत करण्यासाठी आजच या प्रगत तंत्रांचा तुमच्या वर्कफ्लोमध्ये समावेश करण्यास सुरुवात करा.