ჩაის ფუნქციებისა და მეთოდების ტესტირება

 ფუნქციების ტესტირება სწორი გამონაკლისების გამოსაყენებლად

გამონაკლისების შესამოწმებლად, შეგვიძლია გამოვიყენოთ throwჩაის მიერ მოწოდებული მტკიცება. ეს მტკიცება საშუალებას გვაძლევს განვსაზღვროთ გამონაკლისის ტიპი, რომელიც უნდა მოხდეს და ნებისმიერი დამატებითი დეტალი, რომლის დადასტურებაც გვინდა. ამ მტკიცების ჩვენს სატესტო შემთხვევებში ჩართვის შემთხვევაში, ჩვენ შეგვიძლია დავრწმუნდეთ, რომ ჩვენი ფუნქციები იქცევა ისე, როგორც მოსალოდნელია და სათანადოდ უმკლავდება შეცდომის პირობებს.

განვიხილოთ მაგალითი, სადაც გვაქვს ფუნქცია, რომელიც ყოფს ორ რიცხვს. ჩვენ გვსურს უზრუნველვყოთ, რომ ფუნქციამ გამოიყენოს გამონაკლისი ნულზე გაყოფისას. ჩვენ შეგვიძლია დავწეროთ ტესტი ჩაის throwმტკიცების გამოყენებით, რათა შევამოწმოთ, სწორად აგდებს თუ არა ფუნქცია a-ს DivideByZeroErrorნულზე გაყოფისას.

const { expect } = require('chai');

function divide(a, b) {
  if (b === 0) {
    throw new Error('DivideByZeroError');
  }
  return a / b;
}

describe('divide', () => {
  it('should throw DivideByZeroError when dividing by zero', () => {
    expect(() => divide(10, 0)).to.throw('DivideByZeroError');
  });

  it('should return the correct result when dividing two numbers', () => {
    expect(divide(10, 5)).to.equal(2);
  });
});

ზემოხსენებულ მაგალითში, ჩვენ ვიყენებთ to.throwმტკიცებას იმის დასადასტურებლად, რომ divideფუნქცია აგდებს a-ს DivideByZeroErrorნულზე გაყოფისას. მტკიცება შეფუთულია ფუნქციაში, რათა მან შეძლოს გამონაკლისის დაჭერა და საჭირო შემოწმება.

სწორი გამონაკლისის სროლის ტესტების ჩართვის საშუალებით, ჩვენ შეგვიძლია დავრწმუნდეთ, რომ ჩვენი ფუნქციები სათანადოდ უმკლავდება შეცდომის პირობებს და მოგვაწოდებს მნიშვნელოვანი გამოხმაურება მოულოდნელი სიტუაციების დროს. ეს ხელს უწყობს ჩვენი კოდის საერთო ხარისხისა და სანდოობის გაუმჯობესებას.

დასასრულს, ფუნქციების ტესტირება, რომლებიც გამონაკლისებს ქმნიან, პროგრამული უზრუნველყოფის ტესტირების მნიშვნელოვანი ასპექტია. ჩაის throwმტკიცებით, ჩვენ შეგვიძლია მარტივად გადავამოწმოთ, რომ ჩვენი ფუნქციები საჭიროების შემთხვევაში აყენებენ მოსალოდნელ გამონაკლისებს. ამ ტესტების ჩვენს ტესტირების სტრატეგიაში ჩართვით, ჩვენ შეგვიძლია გავაძლიეროთ ჩვენი აპლიკაციების სიმტკიცე და მივცეთ უკეთესი მომხმარებლის გამოცდილება.

"Node.js, Mocha და Chai" სერიის მესამე სტატიაში ჩვენ განვიხილავთ, თუ როგორ შევამოწმოთ ფუნქციები და მეთოდები ჩაის გამოყენებით. Chai არის ძლიერი მტკიცების ბიბლიოთეკა JavaScript კოდის მნიშვნელობებისა და შედეგების შესამოწმებლად.

ობიექტების მეთოდების და მათი ქცევის ტესტირება

ობიექტის მეთოდების შესამოწმებლად, ჩვენ შეგვიძლია გამოვიყენოთ მტკიცებულებები, რომლებიც მოწოდებულია ტესტირების ჩარჩოებით, როგორიცაა Mocha და Chai. ეს მტკიცებები საშუალებას გვაძლევს გავაკეთოთ მტკიცებები ობიექტების თვისებებზე და ქცევაზე.

განვიხილოთ მაგალითი, სადაც გვაქვს ობიექტი, რომელსაც ეწოდება calculatorმიკრების, გამოკლების, გამრავლებისა და გაყოფის მეთოდები. ჩვენ გვინდა დავრწმუნდეთ, რომ ეს მეთოდები დააბრუნებს სწორ შედეგებს. ჩვენ შეგვიძლია დავწეროთ სატესტო შემთხვევები ჩაის მტკიცების გამოყენებით ამ მეთოდების ქცევის შესამოწმებლად.

const { expect } = require('chai');

const calculator = {
  add: (a, b) => a + b,
  subtract: (a, b) => a - b,
  multiply: (a, b) => a * b,
  divide: (a, b) => a / b,
};

describe('calculator', () => {
  it('should return the correct sum when adding two numbers', () => {
    expect(calculator.add(5, 3)).to.equal(8);
  });

  it('should return the correct difference when subtracting two numbers', () => {
    expect(calculator.subtract(5, 3)).to.equal(2);
  });

  it('should return the correct product when multiplying two numbers', () => {
    expect(calculator.multiply(5, 3)).to.equal(15);
  });

  it('should return the correct quotient when dividing two numbers', () => {
    expect(calculator.divide(6, 3)).to.equal(2);
  });
});

ზემოთ მოყვანილ მაგალითში ჩვენ ვიყენებთ ჩაის expectმტკიცებას იმის დასადასტურებლად, რომ ობიექტის მეთოდები calculatorაბრუნებს მოსალოდნელ შედეგებს. თითოეული ტესტის შემთხვევა ფოკუსირებულია კონკრეტულ მეთოდზე და ამოწმებს, აბრუნებს თუ არა სწორ გამომავალს მოცემული შეყვანისთვის.

ამ ტესტის შემთხვევების გაშვებით, ჩვენ შეგვიძლია დავრწმუნდეთ, რომ ობიექტის მეთოდები calculatorიქცევა ისე, როგორც მოსალოდნელია და იძლევა ზუსტ შედეგებს.

მეთოდების დაბრუნების მნიშვნელობების შემოწმების გარდა, ჩვენ ასევე შეგვიძლია გამოვიყენოთ მტკიცებულებები ობიექტების სხვა თვისებებისა და ქცევის შესამოწმებლად. Chai გთავაზობთ მტკიცებების ფართო სპექტრს, რაც საშუალებას გვაძლევს გავაკეთოთ სხვადასხვა სახის მტკიცებები ობიექტებზე, როგორიცაა ქონების მნიშვნელობების შემოწმება, მეთოდების გამოძახების გადამოწმება და სხვა.

ობიექტის მეთოდების საფუძვლიანი ტესტირებით, ჩვენ შეგვიძლია უზრუნველვყოთ მათი სისწორე და სანდოობა, რაც ხელს უწყობს ჩვენი კოდების ბაზის საერთო ხარისხს.