მარტივი ტესტების შექმნა მოკასთან და ჩაისთან ერთად

ძირითადი ტესტის აგება მოკას და ჩაის გამოყენებით

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

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 ბრძანება ტესტების შესასრულებლად. თუ ყველაფერი შეუფერხებლად მიდის, ნახავთ შედეგებს, რომლებიც ნაჩვენებია ტერმინალში.

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

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

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

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

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

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);

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

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

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

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);
  });
});

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

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

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