Add test of syncArticlesFromQiita & pull command

Author: ohakutsu

src/commands/pull.test.ts

@@ -0,0 +1,61 @@
+import { getFileSystemRepo } from "../lib/get-file-system-repo";
+import { getQiitaApiInstance } from "../lib/get-qiita-api-instance";
+import { syncArticlesFromQiita } from "../lib/sync-articles-from-qiita";
+import { pull } from "./pull";
+
+jest.mock("../lib/get-qiita-api-instance");
+jest.mock("../lib/get-file-system-repo");
+jest.mock("../lib/sync-articles-from-qiita");
+const mockGetQiitaApiInstance = jest.mocked(getQiitaApiInstance);
+const mockGetFileSystemRepo = jest.mocked(getFileSystemRepo);
+const mockSyncArticlesFromQiita = jest.mocked(syncArticlesFromQiita);
+
+describe("pull", () => {
+  const qiitaApi = {} as ReturnType<typeof getQiitaApiInstance>;
+  const fileSystemRepo = {} as ReturnType<typeof getFileSystemRepo>;
+
+  beforeEach(() => {
+    mockGetQiitaApiInstance.mockReset();
+    mockGetFileSystemRepo.mockReset();
+    mockSyncArticlesFromQiita.mockReset();
+
+    mockGetQiitaApiInstance.mockReturnValue(qiitaApi);
+    mockGetFileSystemRepo.mockReturnValue(fileSystemRepo);
+    mockSyncArticlesFromQiita.mockImplementation();
+    jest.spyOn(console, "log").mockImplementation();
+  });
+
+  it("pulls articles", async () => {
+    await pull([]);
+
+    expect(mockSyncArticlesFromQiita).toBeCalledWith({
+      fileSystemRepo,
+      qiitaApi,
+      forceUpdate: undefined,
+    });
+    expect(mockSyncArticlesFromQiita).toBeCalledTimes(1);
+  });
+
+  describe('with "--force" option', () => {
+    it("pulls articles with forceUpdate", async () => {
+      await pull(["--force"]);
+
+      expect(mockSyncArticlesFromQiita).toBeCalledWith({
+        fileSystemRepo,
+        qiitaApi,
+        forceUpdate: true,
+      });
+      expect(mockSyncArticlesFromQiita).toBeCalledTimes(1);
+    });
+
+    it("pulls articles with forceUpdate", async () => {
+      await pull(["-f"]);
+
+      expect(mockSyncArticlesFromQiita).toBeCalledWith({
+        fileSystemRepo,
+        qiitaApi,
+        forceUpdate: true,
+      });
+    });
+  });
+});

src/lib/sync-articles-from-qiita.test.ts

@@ -0,0 +1,105 @@
+import type { Item, QiitaApi } from "../qiita-api";
+import type { FileSystemRepo } from "./file-system-repo";
+import { syncArticlesFromQiita } from "./sync-articles-from-qiita";
+import { config } from "./config";
+
+jest.mock("./config");
+const mockConfig = jest.mocked(config);
+
+describe("syncArticlesFromQiita", () => {
+  const qiitaApi = {
+    authenticatedUserItems: () => {},
+  } as unknown as QiitaApi;
+  const fileSystemRepo = {
+    saveItems: () => {},
+  } as unknown as FileSystemRepo;
+
+  const mockAuthenticatedUserItems = jest.spyOn(
+    qiitaApi,
+    "authenticatedUserItems"
+  );
+  const mockSaveItems = jest.spyOn(fileSystemRepo, "saveItems");
+  const mockGetUserConfig = jest.spyOn(mockConfig, "getUserConfig");
+
+  const items = [{ private: false }, { private: true }] as Item[];
+
+  beforeEach(() => {
+    mockAuthenticatedUserItems.mockReset();
+    mockSaveItems.mockReset();
+    mockGetUserConfig.mockReset();
+
+    mockAuthenticatedUserItems.mockImplementation(async (page?: number) => {
+      if (page && page < 2) return items;
+      return [];
+    });
+    mockSaveItems.mockImplementation();
+  });
+
+  describe("with userConfig", () => {
+    describe("when includePrivate is true", () => {
+      it("called saveItems with all item", async () => {
+        mockGetUserConfig.mockImplementation(async () => ({
+          includePrivate: true,
+        }));
+
+        await syncArticlesFromQiita({ fileSystemRepo, qiitaApi });
+
+        expect(mockAuthenticatedUserItems).toHaveBeenNthCalledWith(1, 1, 100);
+        expect(mockAuthenticatedUserItems).toHaveBeenNthCalledWith(2, 2, 100);
+        expect(mockAuthenticatedUserItems).toBeCalledTimes(2);
+        expect(mockSaveItems).toHaveBeenCalledWith(items, false);
+        expect(mockSaveItems).toBeCalledTimes(1);
+      });
+    });
+
+    describe("when includePrivate is false", () => {
+      it("called saveItems with only public item", async () => {
+        mockGetUserConfig.mockImplementation(async () => ({
+          includePrivate: false,
+        }));
+
+        await syncArticlesFromQiita({ fileSystemRepo, qiitaApi });
+
+        expect(mockAuthenticatedUserItems).toHaveBeenNthCalledWith(1, 1, 100);
+        expect(mockAuthenticatedUserItems).toHaveBeenNthCalledWith(2, 2, 100);
+        expect(mockAuthenticatedUserItems).toBeCalledTimes(2);
+        expect(mockSaveItems).toHaveBeenCalledWith([items[0]], false);
+        expect(mockSaveItems).toBeCalledTimes(1);
+      });
+    });
+  });
+
+  describe("with forceUpdate", () => {
+    const expectSaveItemsToBeCalledWithForceUpdate = async (
+      forceUpdate: boolean
+    ) => {
+      mockGetUserConfig.mockImplementation(async () => ({
+        includePrivate: true,
+      }));
+
+      await syncArticlesFromQiita({
+        fileSystemRepo,
+        qiitaApi,
+        forceUpdate,
+      });
+
+      expect(mockAuthenticatedUserItems).toHaveBeenNthCalledWith(1, 1, 100);
+      expect(mockAuthenticatedUserItems).toHaveBeenNthCalledWith(2, 2, 100);
+      expect(mockAuthenticatedUserItems).toBeCalledTimes(2);
+      expect(mockSaveItems).toHaveBeenCalledWith(items, forceUpdate);
+      expect(mockSaveItems).toBeCalledTimes(1);
+    };
+
+    describe("when forceUpdate is true", () => {
+      it("called saveItems without forceUpdate", async () => {
+        await expectSaveItemsToBeCalledWithForceUpdate(true);
+      });
+    });
+
+    describe("when forceUpdate is false", () => {
+      it("called saveItems without forceUpdate", async () => {
+        await expectSaveItemsToBeCalledWithForceUpdate(false);
+      });
+    });
+  });
+});