მარტივი ტესტების შექმნა Mocha და Chai

ძირითადი ტესტის აგება Mocha და Chai

ძირითადი ტესტის შესაქმნელად Mocha და Chai, შეგიძლიათ მიჰყვეთ ამ ნაბიჯებს:

1. დააინსტალირეთ Mocha და Chai: გამოიყენეთ npm(Node Package Manager) ინსტალაციისთვის Mocha და Chai თქვენს Node.js პროექტში. შეასრულეთ შემდეგი ბრძანება თქვენი პროექტის დირექტორიაში:

npm install mocha chai --save-dev

2. შექმენით სატესტო ფაილი: შექმენით ახალი ფაილი, მაგალითად test.js, და შემოიტანეთ შემდეგი დეკლარაციები გამოსაყენებლად Mocha და Chai:

const chai = require('chai');  
const expect = chai.expect;  
  
describe('Example Test Suite',() => {  
  it('should pass the test',() => {  
    expect(2 + 2).to.equal(4);  
  });  
});

3. გაუშვით ტესტი: გახსენით ტერმინალი და გაუშვით mocha  ბრძანება ტესტების შესასრულებლად. თუ ყველაფერი შეუფერხებლად მიდის, ნახავთ შედეგებს, რომლებიც ნაჩვენებია ტერმინალში.

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

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

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

განცხადებებისა და მოთხოვნების გამოყენება ფუნქციის შედეგების შესამოწმებლად

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

1. გამოიყენეთ expect მტკიცება და to.equal მოთხოვნა, რათა შეამოწმოთ ფუნქციის შედეგი, რომელიც აბრუნებს კონკრეტულ მნიშვნელობას:

const result = myFunction();  
expect(result).to.equal(expectedValue);

2. გამოიყენეთ `მოლოდინი` მტკიცება და to.be.true მოთხოვნა to.be.false, რათა შეამოწმოთ ფუნქციის შედეგი, რომელიც აბრუნებს ლოგიკურ მნიშვნელობას:

const result = myFunction();  
expect(result).to.be.true; // or expect(result).to.be.false;

3. გამოიყენეთ `მოლოდინი` მტკიცება და to.be.null ან to.be.undefined მოთხოვნა, რათა შეამოწმოთ ფუნქციის შედეგი, რომელიც აბრუნებს null ან განუსაზღვრელ მნიშვნელობას:

const result = myFunction();  
expect(result).to.be.null; // or expect(result).to.be.undefined;

4. გამოიყენეთ expect მტკიცება და to.include მოთხოვნა, რათა შეამოწმოთ, შედის თუ არა მნიშვნელობა მასივში ან სტრიქონში:

const result = myFunction();  
expect(result).to.include(expectedValue);

5. გამოიყენეთ expect მტკიცება და to.have.lengthOf მოთხოვნა მასივის ან სტრიქონის სიგრძის შესამოწმებლად:

const result = myFunction();  
expect(result).to.have.lengthOf(expectedLength);

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

წარმატებული და წარუმატებელი ტესტის შემთხვევების შექმნა

როდესაც წერთ ტესტის შემთხვევებს Mocha და Chai, მნიშვნელოვანია გაშუქდეს როგორც წარმატებული, ასევე წარუმატებელი სცენარები. აქ მოცემულია სატესტო შემთხვევების შექმნის მაგალითები, როგორც წარმატებული, ასევე წარუმატებელი სცენარებისთვის:

1. წარმატებული ტესტის შემთხვევა:

describe('myFunction',() => {  
  it('should return the expected result',() => {  
    // Arrange  
    const input = // provide the input for the function  
    const expected = // define the expected result  
  
    // Act  
    const result = myFunction(input);  
  
    // Assert  
    expect(result).to.equal(expected);  
  });  
});

2. წარუმატებლობის ტესტის შემთხვევა:

describe('myFunction',() => {  
  it('should throw an error when invalid input is provided',() => {  
    // Arrange  
    const invalidInput = // provide invalid input for the function  
  
    // Act and Assert  
    expect(() => myFunction(invalidInput)).to.throw(Error);  
  });  
});

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

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

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