M

MLOG

ಕನ್ನಡ

ಹೆಚ್ಚು ವಿಶ್ವಾಸಾರ್ಹ ಮತ್ತು ನಿರ್ವಹಿಸಬಲ್ಲ ಸಾಫ್ಟ್‌ವೇರ್ ನಿರ್ಮಿಸಲು ಸುಧಾರಿತ ಜೆಸ್ಟ್ ಪರೀಕ್ಷಾ ಮಾದರಿಗಳನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳಿ. ಜಾಗತಿಕ ಅಭಿವೃದ್ಧಿ ತಂಡಗಳಿಗಾಗಿ ಮಾಕಿಂಗ್, ಸ್ನ್ಯಾಪ್‌ಶಾಟ್ ಟೆಸ್ಟಿಂಗ್, ಕಸ್ಟಮ್ ಮ್ಯಾಚರ್‌ಗಳು ಮತ್ತು ಹೆಚ್ಚಿನ ತಂತ್ರಗಳನ್ನು ಅನ್ವೇಷಿಸಿ.

ಜೆಸ್ಟ್: ದೃಢವಾದ ಸಾಫ್ಟ್‌ವೇರ್‌ಗಾಗಿ ಸುಧಾರಿತ ಪರೀಕ್ಷಾ ಮಾದರಿಗಳು

ಇಂದಿನ ವೇಗದ ಸಾಫ್ಟ್‌ವೇರ್ ಅಭಿವೃದ್ಧಿಯ ಜಗತ್ತಿನಲ್ಲಿ, ನಿಮ್ಮ ಕೋಡ್‌ಬೇಸ್‌ನ ವಿಶ್ವಾಸಾರ್ಹತೆ ಮತ್ತು ಸ್ಥಿರತೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದು ಬಹಳ ಮುಖ್ಯ. ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಟೆಸ್ಟಿಂಗ್‌ಗಾಗಿ ಜೆಸ್ಟ್ ಒಂದು ಡಿ ಫ್ಯಾಕ್ಟೋ ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಆಗಿದ್ದರೂ, ಮೂಲಭೂತ ಯೂನಿಟ್ ಪರೀಕ್ಷೆಗಳನ್ನು ಮೀರಿ ಸಾಗುವುದು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ಹೊಸ ಮಟ್ಟದ ವಿಶ್ವಾಸವನ್ನು ನೀಡುತ್ತದೆ. ಈ ಪೋಸ್ಟ್ ದೃಢವಾದ ಸಾಫ್ಟ್‌ವೇರ್ ನಿರ್ಮಿಸಲು ಅಗತ್ಯವಾದ ಸುಧಾರಿತ ಜೆಸ್ಟ್ ಪರೀಕ್ಷಾ ಮಾದರಿಗಳನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ, ಇದು ಜಾಗತಿಕ ಡೆವಲಪರ್‌ಗಳಿಗಾಗಿ ಉದ್ದೇಶಿಸಲಾಗಿದೆ.

ಮೂಲಭೂತ ಯೂನಿಟ್ ಪರೀಕ್ಷೆಗಳನ್ನು ಏಕೆ ಮೀರಬೇಕು?

ಮೂಲಭೂತ ಯೂನಿಟ್ ಪರೀಕ್ಷೆಗಳು ಪ್ರತ್ಯೇಕ ಕಾಂಪೊನೆಂಟ್‌ಗಳನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ ಪರಿಶೀಲಿಸುತ್ತವೆ. ಆದರೆ, ನೈಜ-ಪ್ರಪಂಚದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಕಾಂಪೊನೆಂಟ್‌ಗಳು ಪರಸ್ಪರ ಸಂವಹನ ನಡೆಸುವ ಸಂಕೀರ್ಣ ವ್ಯವಸ್ಥೆಗಳಾಗಿವೆ. ಸುಧಾರಿತ ಪರೀಕ್ಷಾ ಮಾದರಿಗಳು ಈ ಸಂಕೀರ್ಣತೆಗಳನ್ನು ನಿಭಾಯಿಸಲು ನಮಗೆ ಈ ಕೆಳಗಿನವುಗಳನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತವೆ:

ಮಾಕಿಂಗ್ ಮತ್ತು ಸ್ಪೈಸ್‌ನಲ್ಲಿ ಪ್ರಾವೀಣ್ಯತೆ

ಪರೀಕ್ಷೆಯಲ್ಲಿರುವ ಯೂನಿಟ್ ಅನ್ನು ಅದರ ಅವಲಂಬನೆಗಳನ್ನು ನಿಯಂತ್ರಿತ ಬದಲಿಗಳೊಂದಿಗೆ ಬದಲಾಯಿಸುವ ಮೂಲಕ ಪ್ರತ್ಯೇಕಿಸಲು ಮಾಕಿಂಗ್ ಬಹಳ ಮುಖ್ಯ. ಜೆಸ್ಟ್ ಇದಕ್ಕಾಗಿ ಶಕ್ತಿಯುತ ಸಾಧನಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ:

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}`);
  // ... ಕಾರ್ಯದ ತರ್ಕ ...
  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);
});

ಆಟೋ-ಮಾಕಿಂಗ್ vs. ಮ್ಯಾನುಯಲ್ ಮಾಕಿಂಗ್

ಜೆಸ್ಟ್ ಸ್ವಯಂಚಾಲಿತವಾಗಿ 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 ಕಾಂಪೊನೆಂಟ್‌ಗಳಲ್ಲಿನ ಹಿನ್ನಡೆಗಳನ್ನು ಪತ್ತೆಹಚ್ಚಲು ಇದು ಅಮೂಲ್ಯವಾಗಿದೆ.

ಉದಾಹರಣೆ: ರಿಯಾಕ್ಟ್ ಕಾಂಪೊನೆಂಟ್ ಅನ್ನು ಸ್ನ್ಯಾಪ್‌ಶಾಟ್ ಮಾಡುವುದು

ನೀವು ರಿಯಾಕ್ಟ್ ಕಾಂಪೊನೆಂಟ್ ಹೊಂದಿದ್ದೀರಿ ಎಂದು ಭಾವಿಸೋಣ:

// 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'; // ರಿಯಾಕ್ಟ್ ಕಾಂಪೊನೆಂಟ್ ಸ್ನ್ಯಾಪ್‌ಶಾಟ್‌ಗಳಿಗಾಗಿ
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 ಫ್ಲ್ಯಾಗ್‌ನೊಂದಿಗೆ ರನ್ ಮಾಡುವ ಮೂಲಕ ಸ್ನ್ಯಾಪ್‌ಶಾಟ್ ಅನ್ನು ಅಪ್‌ಡೇಟ್ ಮಾಡಬೇಕಾಗಬಹುದು.

ಸ್ನ್ಯಾಪ್‌ಶಾಟ್ ಟೆಸ್ಟಿಂಗ್‌ಗಾಗಿ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು

ಕಸ್ಟಮ್ ಮ್ಯಾಚರ್‌ಗಳು: ಪರೀಕ್ಷೆಯ ಓದುವಿಕೆಯನ್ನು ಹೆಚ್ಚಿಸುವುದು

ಜೆಸ್ಟ್‌ನ ಅಂತರ್ನಿರ್ಮಿತ ಮ್ಯಾಚರ್‌ಗಳು ವ್ಯಾಪಕವಾಗಿವೆ, ಆದರೆ ಕೆಲವೊಮ್ಮೆ ನೀವು ಒಳಗೊಂಡಿರದ ನಿರ್ದಿಷ್ಟ ಷರತ್ತುಗಳನ್ನು ಪ್ರತಿಪಾದಿಸಬೇಕಾಗುತ್ತದೆ. ಕಸ್ಟಮ್ ಮ್ಯಾಚರ್‌ಗಳು ನಿಮ್ಮ ಸ್ವಂತ ಪ್ರತಿಪಾದನೆಯ ತರ್ಕವನ್ನು ರಚಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತವೆ, ಇದು ನಿಮ್ಮ ಪರೀಕ್ಷೆಗಳನ್ನು ಹೆಚ್ಚು ಅಭಿವ್ಯಕ್ತ ಮತ್ತು ಓದಬಲ್ಲಂತೆ ಮಾಡುತ್ತದೆ.

ಕಸ್ಟಮ್ ಮ್ಯಾಚರ್‌ಗಳನ್ನು ರಚಿಸುವುದು

ನೀವು ನಿಮ್ಮ ಸ್ವಂತ ಮ್ಯಾಚರ್‌ಗಳೊಂದಿಗೆ ಜೆಸ್ಟ್‌ನ expect ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ವಿಸ್ತರಿಸಬಹುದು.

ಉದಾಹರಣೆ: ಮಾನ್ಯ ಇಮೇಲ್ ಫಾರ್ಮ್ಯಾಟ್ ಪರಿಶೀಲಿಸುವುದು

ನಿಮ್ಮ ಜೆಸ್ಟ್ ಸೆಟಪ್ ಫೈಲ್‌ನಲ್ಲಿ (ಉದಾ., jest.setup.js, jest.config.js ನಲ್ಲಿ ಕಾನ್ಫಿಗರ್ ಮಾಡಲಾಗಿದೆ):

// jest.setup.js

expect.extend({
  toBeValidEmail(received) {
    const emailRegex = /^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$/;
    const pass = emailRegex.test(received);

    if (pass) {
      return {
        message: () => `ನಿರೀಕ್ಷಿತ ${received} ಮಾನ್ಯ ಇಮೇಲ್ ಆಗಿರಬಾರದು`,
        pass: true,
      };
    } else {
      return {
        message: () => `ನಿರೀಕ್ಷಿತ ${received} ಮಾನ್ಯ ಇಮೇಲ್ ಆಗಿರಬೇಕು`,
        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();
      // ... ಹೆಚ್ಚಿನ ಪ್ರತಿಪಾದನೆಗಳು ...
    });

    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 () => {
      // ಲಾಗ್‌ಔಟ್ ತರ್ಕವನ್ನು ಪರೀಕ್ಷಿಸಿ...
    });
  });
});

ಸೆಟಪ್ ಮತ್ತು ಟಿಯರ್‌ಡೌನ್ ಹುಕ್ಸ್

ಮಾಕ್ ಡೇಟಾ, ಡೇಟಾಬೇಸ್ ಸಂಪರ್ಕಗಳನ್ನು ಸ್ಥಾಪಿಸಲು ಅಥವಾ ಪರೀಕ್ಷೆಗಳ ನಡುವೆ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಸ್ವಚ್ಛಗೊಳಿಸಲು ಈ ಹುಕ್ಸ್‌ಗಳು ಅತ್ಯಗತ್ಯ.

ಜಾಗತಿಕ ಪ್ರೇಕ್ಷಕರಿಗಾಗಿ ಪರೀಕ್ಷೆ

ಜಾಗತಿಕ ಪ್ರೇಕ್ಷಕರಿಗಾಗಿ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುವಾಗ, ಪರೀಕ್ಷಾ ಪರಿಗಣನೆಗಳು ವಿಸ್ತರಿಸುತ್ತವೆ:

ಅಂತರರಾಷ್ಟ್ರೀಕರಣ (i18n) ಮತ್ತು ಸ್ಥಳೀಕರಣ (l10n)

ನಿಮ್ಮ UI ಮತ್ತು ಸಂದೇಶಗಳು ವಿಭಿನ್ನ ಭಾಷೆಗಳಿಗೆ ಮತ್ತು ಪ್ರಾದೇಶಿಕ ಫಾರ್ಮ್ಯಾಟ್‌ಗಳಿಗೆ ಸರಿಯಾಗಿ ಹೊಂದಿಕೊಳ್ಳುತ್ತವೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.

ಉದಾಹರಣೆ: ಸ್ಥಳೀಕರಿಸಿದ ದಿನಾಂಕ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಅನ್ನು ಪರೀಕ್ಷಿಸುವುದು

// 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); // ನವೆಂಬರ್ 15, 2023
  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 (ಇಂಟಿಗ್ರೇಷನ್ ಪರೀಕ್ಷೆ)
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

ಕವರೇಜ್ ವರದಿಗಳನ್ನು ಪರಿಶೀಲಿಸುವುದು, ಅಂತರರಾಷ್ಟ್ರೀಕರಣ ಮತ್ತು ಸ್ಥಳೀಕರಣ ಕೋಡ್ ಪಥಗಳು ಸೇರಿದಂತೆ, ನಿಮ್ಮ ಸುಧಾರಿತ ಪರೀಕ್ಷಾ ಮಾದರಿಗಳು ನಿರ್ಣಾಯಕ ತರ್ಕವನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಒಳಗೊಳ್ಳುತ್ತಿವೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.

ತೀರ್ಮಾನ

ಸುಧಾರಿತ ಜೆಸ್ಟ್ ಪರೀಕ್ಷಾ ಮಾದರಿಗಳಲ್ಲಿ ಪ್ರಾವೀಣ್ಯತೆ ಪಡೆಯುವುದು ಜಾಗತಿಕ ಪ್ರೇಕ್ಷಕರಿಗಾಗಿ ವಿಶ್ವಾಸಾರ್ಹ, ನಿರ್ವಹಿಸಬಲ್ಲ ಮತ್ತು ಉತ್ತಮ-ಗುಣಮಟ್ಟದ ಸಾಫ್ಟ್‌ವೇರ್ ನಿರ್ಮಿಸುವತ್ತ ಒಂದು ಮಹತ್ವದ ಹೆಜ್ಜೆಯಾಗಿದೆ. ಮಾಕಿಂಗ್, ಸ್ನ್ಯಾಪ್‌ಶಾಟ್ ಟೆಸ್ಟಿಂಗ್, ಕಸ್ಟಮ್ ಮ್ಯಾಚರ್‌ಗಳು ಮತ್ತು ಅಸಮಕಾಲಿಕ ಪರೀಕ್ಷಾ ತಂತ್ರಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಬಳಸಿಕೊಳ್ಳುವ ಮೂಲಕ, ನೀವು ನಿಮ್ಮ ಪರೀಕ್ಷಾ ಸೂಟ್‌ನ ದೃಢತೆಯನ್ನು ಹೆಚ್ಚಿಸಬಹುದು ಮತ್ತು ವಿವಿಧ ಸನ್ನಿವೇಶಗಳು ಮತ್ತು ಪ್ರದೇಶಗಳಲ್ಲಿ ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ನಡವಳಿಕೆಯಲ್ಲಿ ಹೆಚ್ಚಿನ ವಿಶ್ವಾಸವನ್ನು ಗಳಿಸಬಹುದು. ಈ ಮಾದರಿಗಳನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳುವುದು ವಿಶ್ವಾದ್ಯಂತ ಅಭಿವೃದ್ಧಿ ತಂಡಗಳಿಗೆ ಅಸಾಧಾರಣ ಬಳಕೆದಾರ ಅನುಭವಗಳನ್ನು ನೀಡಲು ಅಧಿಕಾರ ನೀಡುತ್ತದೆ.

ನಿಮ್ಮ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಪರೀಕ್ಷಾ ಅಭ್ಯಾಸಗಳನ್ನು ಉನ್ನತೀಕರಿಸಲು ಇಂದೇ ಈ ಸುಧಾರಿತ ತಂತ್ರಗಳನ್ನು ನಿಮ್ಮ ವರ್ಕ್‌ಫ್ಲೋಗೆ ಸೇರಿಸಲು ಪ್ರಾರಂಭಿಸಿ.