डमी के लिए जेस्ट के साथ जावास्क्रिप्ट कोड का परीक्षण। भाग 1

जेस्ट क्या है?

जेस्ट सरलता पर ध्यान देने के साथ एक अद्भुत जावास्क्रिप्ट परीक्षण वातावरण है।

स्थापना

npm install --save-dev jest

yarn add --dev jest

“scripts” : {
     “test”: “jest”
}

npm install jest --global

yarn global add jest

पहले परीक्षण

//first.test.js
test('My first test', () => {
    expect(Math.max(1, 5, 10)).toBe(10);
});

 <b>PASS</b>  ./first.test.js
  ✓ My first test (1 ms)

Test Suites: 1 passed, 1 total
Tests:       1 passed, 1 total
Snapshots:   0 total
Time:        0.618 s, estimated 1 s

//first.test.js
test('My first test', () => {
    expect(Math.max(1, 5, 10)).toBe(5);
});

• toBe() — , , . Object.is(). === 0 -0, NaN c NaN.
• toEqual() — , . . . .
  
  

  test('toEqual with objects', () => {
      expect({ foo: 'foo', subObject: { baz: 'baz' } })
          .toEqual({ foo: 'foo', subObject: { baz: 'baz' } });  // 
      expect({ foo: 'foo', subObject: { num: 0 } })
          .toEqual({ foo: 'foo', subObject: { baz: 'baz' } });  //    .
  });
  
  test('toEqual with arrays', () => {
      expect([11, 19, 5]).toEqual([11, 19, 5]); // 
      expect([11, 19, 5]).toEqual([11, 19]); // 
  });
  

  
  
• toContain() — . ===.
  
  

  const arr = ['apple', 'orange', 'banana'];
  expect(arr).toContain('banana');
  expect(new Set(arr)).toContain('banana');
  expect('apple, orange, banana').toContain('banana');
  

  
  
• toContainEqual() — .
  
  

  expect([{a: 1}, {b: 2}]).toContainEqual({a: 1});
  

  
  
• toHaveLength() — length .
  
  

  expect([1, 2, 3, 4]).toHaveLength(4);
  expect('foo').toHaveLength(3);
  expect({ length: 1 }).toHaveLength(1);
  

  
  
• toBeNull() — null.
• toBeUndefined() — undefined.
• toBeDefined() — toBeUndefined. !== undefined.
• toBeTruthy() — true. false, null, undefined, 0, NaN .
• toBeFalsy() — toBeTruthy(). false.
• toBeGreaterThan() toBeGreaterThanOrEqual() — , >, >=.
• toBeLessThan() toBeLessThanOrEqual() — toBeGreaterThan() toBeGreaterThanOrEqual()
• toBeCloseTo() — , , . .
  
  

  const num = 0.1 + 0.2; // 0.30000000000000004
  expect(num).toBeCloseTo(0.3);
  expect(Math.PI).toBeCloseTo(3.14, 2);
  

  
  
• toMatch() — .
  
  

  expect('Banana').toMatch(/Ba/);
  

  
  
• .Throw () - इसका उपयोग तब किया जाता है जब अपवाद की जांच करना आवश्यक हो। आप दोनों त्रुटि के तथ्य की जांच कर सकते हैं और एक निश्चित वर्ग के अपवादों को जांचने के लिए जाँच सकते हैं, या तो त्रुटि संदेश या संदेश के पत्राचार द्वारा नियमित अभिव्यक्ति के लिए।
  
  

  function funcWithError() {
      throw new Error('some error');
  }   
  expect(funcWithError).toThrow();
  expect(funcWithError).toThrow(Error);
  expect(funcWithError).toThrow('some error');
  expect(funcWithError).toThrow(/some/);
  

  
  
• नहीं - यह संपत्ति आपको असमानता की जांच करने की अनुमति देती है। यह एक ऑब्जेक्ट प्रदान करता है जिसमें ऊपर सूचीबद्ध सभी विधियां हैं, लेकिन वे दूसरे तरीके से काम करेंगे।
  
  

  expect(true).not.toBe(false);
  expect({ foo: 'bar' }).not.toEqual({});
  
  function funcWithoutError() {}
  expect(funcWithoutError).not.toThrow();
  

// src/circle.js
const area = (radius) => Math.PI * radius ** 2;
const circumference = (radius) => 2 * Math.PI * radius;
module.exports = { area, circumference };

// tests/circle.test.js
const circle = require('../src/circle');

test('Circle area', () => {
    expect(circle.area(5)).toBeCloseTo(78.54);
    expect(circle.area()).toBeNaN();
});

test('Circumference', () => {
    expect(circle.circumference(11)).toBeCloseTo(69.1, 1);
    expect(circle.circumference()).toBeNaN();
});

// src/productFilter.js
const byPriceRange = (products, min, max) =>
         products.filter(item => item.price >= min && item.price <= max);
module.exports = { byPriceRange };

// tests/product.test.js
const productFilter = require('../src/producFilter');

const products = [
    { name: 'onion', price: 12 },
    { name: 'tomato', price: 26 },
    { name: 'banana', price: 29 },
    { name: 'orange', price: 38 }
];

test('Test product filter by range', () => {
    const FROM = 15;
    const TO = 30;
    const filteredProducts = productFilter.byPriceRange(products, FROM, TO);

    expect(filteredProducts).toHaveLength(2);
    expect(filteredProducts).toContainEqual({ name: 'tomato', price: 26 });
    expect(filteredProducts).toEqual([{ name: 'tomato', price: 26 }, { name: 'banana', price: 29 }]);
    expect(filteredProducts[0].price).toBeGreaterThanOrEqual(FROM);
    expect(filteredProducts[1].price).toBeLessThanOrEqual(TO);
    expect(filteredProducts).not.toContainEqual({ name: 'orange', price: 38 });
});