Test Test Diye Nice Nice: Mocklama (2) - Modül

Enes Başpınar /25 Eki 2022

21 min read •––– views

Bölümler

Test Test Diye Nice Nice: Mocklama (1) - Fonksiyon
Test Test Diye Nice Nice: Mocklama (2) - Modül (Şu anda buradasınız)
Test Test Diye Nice Nice: Mocklama (3) - Timer
Test Test Diye Nice Nice: Mocklama (4) - React

kaynak

İçerik

Modül Nedir?
Girizgah
Modül Mocklama
Spesifik Testlerde Modül Mocklamak
- jest.doMock()
- jest.spyOn()
Modül Mockunu Temizleme

Önceki yazıda mock kavramının ne olduğuna ve hangi ihtiyaçtan doğduğuna değindik. Kütüphane ve built-in metodların mocklanış yöntemlerinden bahsettik. Artık modüllere böldüğümüz fonksiyonları nasıl mocklayabileceğimize göz atalım.

Yazının kodlarına Github üzerinden erişebilirsiniz.

Modül Nedir?

Uygulamalar büyüdükçe dosyalara bölme ihtiyacı hissedilmeye başlanır. Fonksiyon gruplarını içeren bu dosyalara modül denir. Mocklarken hangi yöntemleri kullanabileceğimiz anlayabilmek için içe aktarılan dosyaların içeriklerine (nesne mi? değerleri neler?) göz atacağız.

CommonJs kullanarak yapabileceğimiz farklı import çeşitleri:

Dosyaların içeriklerini görmek için sekmeler arasında geçiş yapabilirsiniz.

utils.test.ts

utils.ts

const utils = require("./utils");
const { getProduct } = require("./utils");
test("playground", () => {
  console.log("require with default:", utils);
  console.log("require with partial :", getProduct);
}

=== Output:require with default: {
  get: [Function: get],
  getUser: [Function: getUser],
  getProduct: [Function: getProduct],
  default: {
    get: [Function: get],
    getUser: [Function: getUser],
    getProduct: [Function: getProduct]
  }
}
require with partial : [Function: getProduct]

ES Modules kullanarak yapabileceğimiz farklı import çeşitleri:

utils.test.ts

utils.ts

import * as utilsWithStar from "./utils";
import utilsWithDefault, { getProduct } from "./utils";
test("playground", () => {
  console.log("import with * as:", utilsWithStar);
  console.log("import with default:", utilsWithDefault);
  console.log("import with partial:", getProduct);
});

=== Output:import with * as: {
  get: [Function: get],
  getUser: [Function: getUser],
  getProduct: [Function: getProduct],
  default: {
    get: [Function: get],
    getUser: [Function: getUser],
    getProduct: [Function: getProduct]
  }
}
import with default: {
  get: [Function: get],
  getUser: [Function: getUser],
  getProduct: [Function: getProduct]
}
import with partial: [Function: getProduct]

Farklı içe aktarma yöntemlerinin farklarına sıradaki başlıkta değineceğiz.

Girizgah

Uygulamamızda ürün ve kullanıcı bilgilerini çekmek için yardımcı fonksiyonlara sahip olduğumuzu varsayalım.

Kod kümelerimizi yardımcı metodlara çıkarma işlemine abstraction denir. Örneğin ürün bilgisini çekmek görevini ifa eden kodları getProduct() isimli bir fonksiyona yerleştirebiliriz. Koda bakan birisi bu fonksiyonunun ne döndüreceğini isminden anlayabilmelidir. Abstraction'ı sevelim çünkü test yazılmasını inanılmaz derecede kolaylaştırır.

utils.ts

import axios from "axios";
const API_URL = "https://dummyjson.com";
export async function get(apiUrl: string): Promise<any> {
  try {
    const response = await axios.get(apiUrl);
    return response.data;
  } catch (error) {
    return null;
  }
}
export function getProduct(productId: number): Promise<any> {
  return get(`${API_URL}/products/${productId}`);
}
export function getUser(userId: number): Promise<any> {
  return get(`${API_URL}/users/${userId}`);
}

Elimizdeki bilgilerle mocklamayı deneyelim. İlk akla gelen import edip ezerek override etmek olabilir.

utils.test.ts

import { get } from "./index";
test("should be mock", () => {
  get = jest.fn();
  expect(jest.isMockFunction(get)).toBe(true);
});

=== Output:error TS2632: Cannot assign to 'get' because it is an import.

Mocklamaya çalıştığımız fonksiyonun import olduğuna dair uyarı ile karşılaştık. Dosyanın nesne olarak import edilmesinin çözüm olacağını düşünebiliriz.

utils.test.ts

import * as UtilsModule from "./index";
// `import Utils from "./index"` yapmayı denerseniz default
// export'a sahip olmadığına dair uyarı alırsınız.
test("should be mock", () => {
  UtilsModule.get = jest.fn();
  expect(jest.isMockFunction(UtilsModule.get)).toBe(true);
});

=== Output:error TS2540: Cannot assign to 'get' because it is a read-only property.

Ancak alnımızın çatına TypeScript hatasını yeriz. Olsun, güzel denemeydi. Zaten import'un direkt ezmek güzel bir uygulama olmazdı. Bu işi Jest'in maharetli ellerine bırakalım.

Modül Mocklama

Modülleri mocklamak için jest.mock(relativeFilePath, factory, options) kullanılır. Yalnızca dosya yolu verilmişse export edilen tüm metodları otomatik mocklar.

utils.test.ts

utils.ts

import * as utils from "./utils";
jest.mock("./utils");
test("playground", () => {
  console.log("utils Module:", utils);
});

=== Output:utils Module: {
  __esModule: true,
  getProduct: [Function: getProduct] {
    _isMockFunction: true,
    getMockImplementation: [Function (anonymous)],
    mock: [Getter/Setter],
    mockClear: [Function (anonymous)],
    mockReset: [Function (anonymous)],
    mockRestore: [Function (anonymous)],
    mockReturnValueOnce: [Function (anonymous)],
    mockResolvedValueOnce: [Function (anonymous)],
    mockRejectedValueOnce: [Function (anonymous)],
    mockReturnValue: [Function (anonymous)],
    mockResolvedValue: [Function (anonymous)],
    mockRejectedValue: [Function (anonymous)],
    mockImplementationOnce: [Function (anonymous)],
    withImplementation: [Function: bound withImplementation],
    mockImplementation: [Function (anonymous)],
    mockReturnThis: [Function (anonymous)],
    mockName: [Function (anonymous)],
    getMockName: [Function (anonymous)]
  },
  getUser: [Function: getUser] {
    _isMockFunction: true,
    ...
  },
  default: [Function: get] {
    _isMockFunction: true,
    ...
  }
}

Dosya yolunu mockladığımızda kendisini çağıran import'lar takip edilerek sahte modül döndürülür. Ancak unutmayalım ki test dosyasının içindeki modül çağrısı da mocklanmış olur.

import * as UtilsModule from "./utils";
jest.mock("./utils");
test("playground", () => {
  expect(jest.isMockFunction(UtilsModule.get)).toBe(true);
});

=== Output:PASS  src/utils.test.ts
  ✓ playground

Fonksiyonları kullanmadan önce mocklamıştık. Modüllerin de import edilmeden önce mocklanması gerekmez mi?

Çok güzel bir noktaya parmak bastın. Herhangi bir nesnenin kullanılmadan önce mocklanması zorunludur. Fakat biliyoruz ki import ifadelerinin dosyanın en üstünde olması JS yazılımcılarının genel alışkanlığıdır. Jest'de bu yapıyı bozmamak adına jest. mock ifadelerini hoist eder yani import'un üzerine taşır.

Jest'in sınırlarını keşfetmeye devam edelim.

Modül Fonksiyonların İmplementasyonunun Mocklanması

Mocklanan modüllerdeki fonksiyonlara varsayılan olarak jest.fn() atanır. Dolayısıyla implementasyonu ya da dönüş değerini önceki yazıdaki yöntemlerle mocklayabiliriz.

Utils modülümüzün testlerine get ile başlayalım. İçerisinde axios paketinin bir metodu kullanılmıştır ve bu paketi yani modülü mocklamamız gerekir.

utils.test.ts

utils.ts

import axios from "axios";
import * as UtilsModule from "./utils";
// axios paketini mockluyoruz.
jest.mock("axios");
// jest metodlarının tiplerini modül fonksiyonlarına sarıyoruz.
const mockedAxios = jest.mocked(axios);
describe("utils tests", () => {
  afterEach(() => {
    jest.clearAllMocks();
  });
  describe("get() tests", () => {
    test("should return product when request is success", async () => {
      // fonksiyonumuzun verdiğimiz parametreyi axios.get'e doğru
      // şekilde ilettiğini test etmek için url'i değişkene atıyoruz.
      const apiUrl = "https://dummyjson.com/product/1";
      // sahte ürünümüzü oluşturuyoruz.
      const mockProduct = {
        id: 1,
        title: "iPhone 9",
        description: "An apple mobile which is nothing like apple",
        price: 549,
        discountPercentage: 12.96,
        rating: 4.69,
        stock: 94,
        brand: "Apple",
        category: "smartphones",
      };
      // test ettiğimiz fonksiyon içerisindeki farklı pakete bağımlı
      // olan axios.get fonksiyonunun çağrıldığında mock veri ile
      // resolve olmasını sağlıyoruz.
      mockedAxios.get.mockResolvedValueOnce({
        data: mockProduct,
      });
      // test edeceğimiz fonksiyonu çağırıyoruz.
      const result = await UtilsModule.get(apiUrl);
      // axios.get'in ilettiğimiz url ile çağrıldığını test ediyoruz
      expect(mockedAxios.get).toHaveBeenCalledWith(apiUrl);
      // istek başarısız olduğu zaman null döndürdüğünü test ediyoruz.
      expect(result).toStrictEqual(mockProduct);
    });
    test("should return null when request is failed", async () => {
      const apiUrl = "https://dummyjson.com/product/1000";
      mockedAxios.get.mockRejectedValueOnce(
        new Error("Error occured when fetching data!")
      );
      const result = await UtilsModule.get(apiUrl);
      expect(mockedAxios.get).toHaveBeenCalledWith(apiUrl);
      expect(result).toBeNull();
    });
  });
});

=== Output:PASS  src/tests/utils.test.ts
  utils tests
    get() tests
      ✓ should return product whe request is success
      ✓ should return null when request is failed

Jest, modülleri mockladıktan sonra kendi metodları için TypeScript tiplerini eklemez. Barındırdığı tüm fonksiyonlara Jest metodlarının tiplerini sarmalamak istersek jest.mocked(source) metodunu kullanabiliriz.

Factory Parametresi

Modül mocklanırken fonksiyonların otomatik mocklanmasını istemiyorsak ve kendimiz konfigüre edeceksek factory parametresini kullanabiliriz. Örneğimizde eğer dönüş değeri mocklanmamışsa reject edecek bir yapı kuralım ve ikinci testi refactor edelim.

import axios from "axios";
import * as UtilsModule from "./utils";
jest.mock("axios", () => {
  return {
    get: jest
      .fn()
      .mockRejectedValue(new Error("Error occured when fetching data!")),
  };
});
const mockedAxios = jest.mocked(axios);
describe("utils tests", () => {
  afterEach(() => {
    jest.clearAllMocks();
  });
  describe("get() tests", () => {
    test("should return product when request is success", async () => {
      const apiUrl = "https://dummyjson.com/product/1";
      const mockProduct = {
        id: 1,
        title: "iPhone 9",
        description: "An apple mobile which is nothing like apple",
        price: 549,
        discountPercentage: 12.96,
        rating: 4.69,
        stock: 94,
        brand: "Apple",
        category: "smartphones",
      };
      mockedAxios.get.mockResolvedValueOnce({
        data: mockProduct,
      });
      const result = await UtilsModule.get(apiUrl);
      expect(mockedAxios.get).toHaveBeenCalledWith(apiUrl);
      expect(result).toStrictEqual(mockProduct);
    });
    test("should return null when request is failed", async () => {
      const apiUrl = "https://dummyjson.com/product/1000";
      const result = await UtilsModule.get(apiUrl);
      expect(mockedAxios.get).toHaveBeenCalledWith(apiUrl);
      expect(result).toBeNull();
    });
  });
});

=== Output:PASS  src/tests/utils.test.ts
  utils tests
    get() tests
      ✓ should return product whe request is success
      ✓ should return null when request is failed

Peki ne zaman factory kullanmalıyız?

Fonksiyonların mocklamaları testler boyunca aynı kalacaksa, default mock değeri tanımlamamız gerekiyorsa ya da kısmi mocklama yapacaksak kullanabiliriz.

Dikkat etmemiz gereken önemli bir nokta, factory ve test içerisinde mockların ahengidir. Lafı uzatmadan şu üç farklı kullanımı özümseyelim.

import axios from "axios";
jest.mock("axios", () => {
  return {
    get: jest.fn().mockResolvedValue("Mock in module factory"),
  };
});
const mockedAxios = jest.mocked(axios);
test("playground", async () => {
  const apiUrl = "https://dummyjson.com";
  mockedAxios.get.mockResolvedValue("Mock in test");
  console.log(await mockedAxios.get(apiUrl)); // Output: Mock in test
  console.log(await mockedAxios.get(apiUrl)); // Output: Mock in test
});

import axios from "axios";
jest.mock("axios", () => {
  return {
    get: jest.fn().mockResolvedValue("Mock in module factory"),
  };
});
const mockedAxios = jest.mocked(axios);
test("playground", async () => {
  const apiUrl = "https://dummyjson.com";
  mockedAxios.get.mockResolvedValueOnce("Mock in test");
  console.log(await mockedAxios.get(apiUrl)); // Output: Mock in test
  console.log(await mockedAxios.get(apiUrl)); // Output: Mock in module factory
});

import axios from "axios";
jest.mock("axios", () => {
  return {
    get: jest.fn().mockResolvedValueOnce("Mock in module factory"),
  };
});
const mockedAxios = jest.mocked(axios);
test("playground", async () => {
  const apiUrl = "https://dummyjson.com";
  mockedAxios.get.mockResolvedValue("Mock in test");
  console.log(await mockedAxios.get(apiUrl)); // Output: Mock in module factory
  console.log(await mockedAxios.get(apiUrl)); // Output: Mock in test
});

import axios from "axios";
jest.mock("axios", () => {
  return {
    get: jest.fn().mockResolvedValueOnce("Mock in module factory"),
  };
});
const mockedAxios = jest.mocked(axios);
test("playground", async () => {
  const apiUrl = "https://dummyjson.com";
  mockedAxios.get.mockResolvedValueOnce("Mock in test");
  console.log(await mockedAxios.get(apiUrl)); // Output: Mock in module factory
  console.log(await mockedAxios.get(apiUrl)); // Output: Mock in test
});

Kısmi Mocklama

Şimdiye kadar daima tüm modülü mockladık. Ancak yalnızca bazı işlevleri mocklamak isteyebiliriz. Modüllerin gerçek içeriğine erişmek için jest.requireActual kullanılır.

jest.mock('../moduleName', () => {
  const originalModule = jest.requireActual('../moduleName');
  return {
    __esModule: true,
    ...originalModule,
    functionThatBeMock: jest.fn(),
  };
});

Spesifik Testlerde Modül Mocklamak

get fonksiyonun testlerini yazdık. Dilerseniz getProduct testine geçelim. Test ettiğimiz foksiyonun bağımlı olduğu diğer fonksiyonları mocklamak iyi bir pratiktir. Bu sebeple getProduct içerisinde kullanılan get fonksiyonunu mocklayacağız.

import axios from "axios";
import * as UtilsModule from "./utils";
jest.mock("./utils");
jest.mock("axios", () => {
  return {
    get: jest
      .fn()
      .mockRejectedValue(new Error("Error occured when fetching data!")),
  };
});
const mockedUtils = jest.mocked(UtilsModule);
const mockedAxios = jest.mocked(axios);
describe("utils tests", () => {
  // ...
  describe("getProduct() tests", () => {
    test("should call get func with api product endpoint when given product id", () => {
      const productId = 1;
      const mockProduct = {
        id: 1,
        title: "iPhone 9",
        description: "An apple mobile which is nothing like apple",
        price: 549,
        discountPercentage: 12.96,
        rating: 4.69,
        stock: 94,
        brand: "Apple",
        category: "smartphones",
      };
      mockedUtils.get.mockResolvedValue(mockProduct);
      const result = UtilsModule.getProduct(productId);
      expect(UtilsModule.get).toHaveBeenCalledWith(
        `https://dummyjson.com/products/${productId}`
      );
      expect(result).toStrictEqual(mockProduct);
    });
  });
});

=== Output:utils tests
    get() tests
      ✕ should return product whe request is success (4 ms)
      ✕ should return null when request is failed
    getProduct() tests
      ✕ should call get func with api product endpoint when given product id
  ● utils tests › get() tests › should return product whe request is success
    Expected: "https://dummyjson.com/product/1"
    Number of calls: 0
  ● utils tests › get() tests › should return null when request is failed
    Expected: "https://dummyjson.com/product/1000"
    Number of calls: 0
  ● utils tests › getProduct() tests › should call get func with api product endpoint when given product id
    Expected: "https://dummyjson.com/products/1"
    Number of calls: 0

Hoppalaa... Yeni testimiz patladı, üstüne üstlük geçen testlerde patlamaya başladı. Çıktıyı incelediğimizde, mockladığımız fonksiyonların çağırılmadığını anlıyoruz. Jest bize, "Sen bi değerle çağırılmasını bekliyordun fakat bu fonksiyon hiç çağırılmadı." diyor.

getProduct fonksiyonunun implementasyonunu mocklamak için Utils modülünü mockladık. Ancak testi için orijinal implementasyonuna ihtiyaç duyduğumuz get fonksiyonu da mocklanmış oldu. Test bazlı fonksiyon mocklamak işimize yarardı. Bu problemi birkaç farklı yöntemle çözebiliriz.

jest.doMock()

Jest'te modül mocklamanın diğer bir yolu jest.doMock() kullanmaktır. Bunun jest.mock'tan farkı, hoist edilmiyor olmasıdır. Yani sadece kendisinden sonra yazılan importları mocklar.

Mocklanmasını beklediğiniz bir modül mocklanmamışsa import edildikten sonra mocklanmış olma ihtimali çok yüksektir. Kontrol etmeyi unutmayın.

import axios from "axios";
import UtilsModule from "./utils";
jest.mock("axios", () => {
  return {
    get: jest.fn().mockRejectedValue(new Error("Error occured when fetching data!")),
  };
});
const mockedAxios = jest.mocked(axios);
describe("utils tests", () => {
  afterEach(() => {
    jest.clearAllMocks();
    // bu dosyadaki tüm modül mockları temizler.
    jest.resetModules();
  });
  //...
  describe("getProduct() tests", () => {
    test("should call get func with api product endpoint when given product id", () => {
      const productId = 1;
      const mockProduct = {
        id: 1,
        title: "iPhone 9",
        description: "An apple mobile which is nothing like apple",
        price: 549,
        discountPercentage: 12.96,
        rating: 4.69,
        stock: 94,
        brand: "Apple",
        category: "smartphones",
      };
      jest.doMock("./utils", () => ({
        __esModule: true,
        ...jest.requireActual("./utils"),
        get: jest.fn().mockResolvedValue(mockProduct),
      }));
       // burası kritik bir nokta. doMock hoist edilmeyeceği
      // için sonrasında yaptığımız require'ı kullanmalıyız.
      const GetModule = require("./utils");
      const UtilsModule = require("./utils");
      const result = UtilsModule.getProduct(productId);
      expect(GetModule.default).toHaveBeenCalledWith(`https://dummyjson.com/products/${productId}`);
      expect(result).toStrictEqual(mockProduct);
    });
  });
});

get metodunu mocklayamadığımıza dair bir hata aldık. getProduct ve get aynı dosyada yer aldığı ve biz mocklamak için import beklediğimizden dolayı başarısız olur. Teyit etmek için mockedUtils değişkenini yazdıralım.

test("should call get func with api product endpoint when given product id", () => {
  // ...
  const UtilsModule = require("./utils");
  console.log("get:", UtilsModule.get);
  // ...
})

=== Output:get: [Function: mockConstructor] {
  _isMockFunction: true,
  getMockImplementation: [Function (anonymous)],
  mock: [Getter/Setter],
  mockClear: [Function (anonymous)],
  mockReset: [Function (anonymous)],
  mockRestore: [Function (anonymous)],
  mockReturnValueOnce: [Function (anonymous)],
  mockResolvedValueOnce: [Function (anonymous)],
  mockRejectedValueOnce: [Function (anonymous)],
  mockReturnValue: [Function (anonymous)],
  mockResolvedValue: [Function (anonymous)],
  mockRejectedValue: [Function (anonymous)],
  mockImplementationOnce: [Function (anonymous)],
  withImplementation: [Function: bound withImplementation],
  mockImplementation: [Function (anonymous)],
  mockReturnThis: [Function (anonymous)],
  mockName: [Function (anonymous)],
  getMockName: [Function (anonymous)]
}

Şimdi getProduct içinde get fonksiyonunu yazdıralım.

export function getProduct(productId: number): Promise<any> {
  console.log("get Function: ", get.toString());
  // ...
}

=== Output:get Function: [Function: get]

Düşündüğümüz gibi fonksiyon mocklanmamış. Ayrı bir dosyaya çıkarıp yeni dosya üzerinden mocklayabiliriz.

utils.test.ts

utils.ts

get.ts

import axios from "axios";
import * as GetModule from "./get";
jest.mock("axios", () => {
  return {
    get: jest.fn().mockRejectedValue(new Error("Error occured when fetching data!")),
  };
});
const mockedAxios = jest.mocked(axios);
describe("utils tests", () => {
  afterEach(() => {
    jest.clearAllMocks();
    jest.resetModules(); // clears all module mocks in this file.
  });
  describe("get() tests", () => {
    test("should return product when request is success", async () => {
      const apiUrl = "https://dummyjson.com/product/1";
      const mockProduct = {
        id: 1,
        title: "iPhone 9",
        description: "An apple mobile which is nothing like apple",
        price: 549,
        discountPercentage: 12.96,
        rating: 4.69,
        stock: 94,
        brand: "Apple",
        category: "smartphones",
      };
      mockedAxios.get.mockResolvedValueOnce({
        data: mockProduct,
      });
      const result = await GetModule.default(apiUrl);
      expect(mockedAxios.get).toHaveBeenCalledWith(apiUrl);
      expect(result).toStrictEqual(mockProduct);
    });
    test("should return null when request is failed", async () => {
      const apiUrl = "https://dummyjson.com/product/1000";
      const result = await GetModule.default(apiUrl);
      expect(mockedAxios.get).toHaveBeenCalledWith(apiUrl);
      expect(result).toBeNull();
    });
  });
  describe("getProduct() tests", () => {
    test("should call get func with api product endpoint when given product id", async () => {
      const productId = 1;
      const mockProduct = {
        id: 1,
        title: "iPhone 9",
        description: "An apple mobile which is nothing like apple",
        price: 549,
        discountPercentage: 12.96,
        rating: 4.69,
        stock: 94,
        brand: "Apple",
        category: "smartphones",
      };
      jest.doMock("./get", () => {
        return {
          __esModule: true,
          default: jest.fn().mockResolvedValue(mockProduct),
        };
      });
      const GetModule = require("./get");
      const UtilsModule = require("./utils");
      const result = await UtilsModule.getProduct(productId);
      expect(GetModule.default).toHaveBeenCalledWith(`https://dummyjson.com/products/${productId}`);
      expect(result).toStrictEqual(mockProduct);
    });
  });
});

=== Output:utils tests
  get() tests
    ✓ should return product whe request is success (4 ms)
    ✓ should return null when request is failed
  getProduct() tests
    ✓ should call get func with api product endpoint when given product id

jest.spyOn()

Eski bir dostla karşılaşmış gibiyiz. Evet, modüllerde de jest.spyOn() kullanabiliriz. Ayrı dosyaya çıkartmak bu yöntemle de gerekli olsa bile çok daha temiz bir kullanım sağlar.

utils.test.ts

utils.ts

get.ts

import axios from "axios";
import * as GetModule from "./get";
import * as UtilsModule from "./utils";
jest.mock("axios", () => {
  return {
    get: jest
      .fn()
      .mockRejectedValue(new Error("Error occured when fetching data!")),
  };
});
const mockedAxios = jest.mocked(axios);
describe("utils tests", () => {
  // ...
  describe("getProduct() tests", () => {
    test("should call get func with api product endpoint when given product id", async () => {
      const productId = 1;
      const mockProduct = {
        id: 1,
        title: "iPhone 9",
        description: "An apple mobile which is nothing like apple",
        price: 549,
        discountPercentage: 12.96,
        rating: 4.69,
        stock: 94,
        brand: "Apple",
        category: "smartphones",
      };
      jest.spyOn(GetModule, "default").mockResolvedValue(mockProduct);
      const result = await UtilsModule.getProduct(productId);
      expect(GetModule.default).toHaveBeenCalledWith(
        `https://dummyjson.com/products/${productId}`
      );
      expect(result).toStrictEqual(mockProduct);
    });
  });
});

=== Output:utils tests
  get() tests
    ✓ should return product whe request is success (4 ms)
    ✓ should return null when request is failed
  getProduct() tests
    ✓ should call get func with api product endpoint when given product id

Modül Mockunu Temizleme

Modülleri mockladık ancak mockları temizlemek de isteyebiliriz. Bunun için iki methoda sahibiz. jest.dontMock() kendinden sonraki import nesnelerinin mocklarını temizler.

jest.mock("axios");
test("playground", () => {
  const axiosInstance1 = require("axios"); // mocked
  console.log(
    "Is axiosInstance1.get mocked:",
    jest.isMockFunction(axiosInstance1.get)
  );
  jest.dontMock("axios");
  const axiosInstance2 = require("axios"); // unmocked
  console.log(
    "Is axiosInstance2.get mocked:",
    jest.isMockFunction(axiosInstance2.get)
  );
});

=== Output:Is axiosInstance1.get mocked: true
Is axiosInstance2.get mocked: false

jest.unmock() ise bulunduğu kod bloğundaki ilgili tüm import nesnelerinin mocklarını temizler.

jest.mock("axios");
test("playground", () => {
  const axiosInstance1 = require("axios"); // mocked
  console.log(
    "Is axiosInstance1.get mocked:",
    jest.isMockFunction(axiosInstance1.get)
  );
  jest.unmock("axios");
  const axiosInstance2 = require("axios"); // unmocked
  console.log(
    "Is axiosInstance2.get mocked:",
    jest.isMockFunction(axiosInstance2.get)
  );
});

=== Output:Is axiosInstance1.get mocked: false
Is axiosInstance2.get mocked: false

Kapanış

İşin içine girip gerçek senaryolarla ilgili kod yazmadıkça test öğrenmek zor görünebilir. Ancak olumsuz bir yargıya varmayın istediğimiz takdirde öğrenebileceğimizi biliyoruz.

Yazı burada biter. Sağlıcakla kalın.

Kaynaklar

https://jestjs.io/docs