@secrecy/lib 1.0.0-dev.24 → 1.0.0-dev.27

package/__tests__/client/client.test.ts

@@ -0,0 +1,81 @@
+import { chrisId, raphId, chris, raph, axel, axelId } from "./utils.js";
+import { setup } from "../../src/index.js";
+
+beforeAll(setup);
+
+describe("SecrecyClient", () => {
+  test("me", async () => {
+    const chrisMe = await chris.me({ withPublicKey: true });
+    if (!chrisMe) {
+      throw new Error("undefined or null: chrisMe");
+    }
+    if (chrisMe.__typename === "ErrorNotFound") {
+      throw new Error("chrisMe not found");
+    }
+    expect(chrisMe.data).toMatchObject({
+      email: "chris@secrecy.me",
+      firstname: "Christopher",
+      id: chrisId,
+      lastname: "Yovanovitch",
+      phone: "+33783263010",
+      publicKey: chris.publicKey,
+      role: "admin"
+    });
+    const raphMe = await raph.me({ withPublicKey: true });
+    if (!raphMe) {
+      throw new Error("undefined or null: raphMe");
+    }
+    if (raphMe.__typename === "ErrorNotFound") {
+      throw new Error("raphMe not found");
+    }
+    expect(raphMe.data).toMatchObject({
+      email: "raphaelmortier@outlook.fr",
+      firstname: "Raphaël",
+      id: raphId,
+      lastname: "Mortier",
+      phone: "+33622471563",
+      publicKey: raph.publicKey,
+      role: "admin"
+    });
+    const axelMe = await axel.me({ withPublicKey: true });
+    if (!axelMe) {
+      throw new Error("undefined or null: axelMe");
+    }
+    if (axelMe.__typename === "ErrorNotFound") {
+      throw new Error("axelMe not found");
+    }
+    expect(axelMe.data).toMatchObject({
+      email: "axel.lavoie@gmail.com",
+      firstname: "Axel",
+      id: axelId,
+      lastname: "Lavoie",
+      phone: "+33627464948",
+      publicKey: axel.publicKey,
+      role: "admin"
+    });
+  });
+
+  test("limits", async () => {
+    const limits = await chris.limits();
+    if (!limits) {
+      throw new Error("limits not found");
+    }
+    if (limits.__typename === "ErrorAccessDenied") {
+      throw new Error("ErrorAccessDenied");
+    }
+    if (limits.__typename === "ErrorLimit") {
+      throw new Error("ErrorLimit");
+    }
+    if (limits.__typename === "ErrorNotExist") {
+      throw new Error("ErrorNotExist");
+    }
+    if (limits.__typename === "ErrorNotFound") {
+      throw new Error("ErrorNotFound");
+    }
+    expect(limits.data).toMatchObject({
+      cloud: {
+        maxCount: 10000n
+      }
+    });
+  });
+});

package/__tests__/client/folder.test.ts

@@ -0,0 +1,302 @@
+import { chris, raph, raphId } from "./utils.js";
+import { Rights, setup } from "../../src/index.js";
+
+beforeAll(setup);
+
+beforeAll(async () => {
+  await Promise.all([chris.emptyCloudTrash(), raph.emptyCloudTrash()]);
+});
+
+describe("SecrecyClient - Folders", () => {
+  test("wrong folder", async () => {
+    //wrong folder
+    const folder = await chris.folder({
+      id: "id"
+    });
+    expect(folder).toBeNull();
+  });
+
+  test("shareFolder", async () => {
+    //root folder
+    const rootFolder = await chris.folder();
+    expect(rootFolder).not.toBeNull();
+    if (!rootFolder) {
+      throw new Error("empty or undefined value: rootFolder");
+    }
+
+    if (rootFolder.__typename === "ErrorAccessDenied") {
+      expect(rootFolder.message).toBe("Access denied");
+    }
+    if (rootFolder.__typename === "SuccessResponse") {
+      const cloudFolder = rootFolder.data.subfolders.find(
+        f => f.name === "cloud"
+      );
+      expect(cloudFolder).not.toBeUndefined();
+      if (!cloudFolder) {
+        throw new Error("empty or undefined value: cloudFolder");
+      }
+
+      //create folder
+      const name = "test_folder_to_share";
+      const folderToShare = await chris.createFolder({
+        name,
+        parentFolderId: cloudFolder.id
+      });
+
+      expect(folderToShare).not.toBeNull();
+      if (!folderToShare) {
+        throw new Error("empty or undefined value: folderToShare");
+      }
+
+      if (folderToShare.__typename !== "SuccessResponse") {
+        throw new Error("folderToShare is not a SuccessResponse");
+      }
+
+      //share folder
+      const res = await chris.shareFolder({
+        folderId: folderToShare.data.id,
+        rights: Rights.write,
+        userId: raphId
+      });
+      expect(res).toStrictEqual({ __typename: "SuccessResponse", data: true });
+      const allShared = await raph.foldersSharedWithMe();
+      if (!allShared) {
+        throw new Error("empty or undefined value: allShared");
+      }
+
+      if (allShared.__typename === "ErrorAccessDenied") {
+        throw new Error("Access denied");
+      }
+
+      if (allShared.__typename === "SuccessResponse") {
+        const folderShared = allShared.data.find(
+          f => f.id === folderToShare.data.id
+        );
+        expect(folderShared).not.toBeUndefined();
+        if (!folderShared) {
+          throw new Error("empty or undefined value: folderShared");
+        }
+
+        expect(folderShared.name).toBe(name);
+
+        //create folder in shared folder
+        const nameFolder = "test";
+        await raph.createFolder({
+          name: nameFolder,
+          parentFolderId: folderToShare.data.id
+        });
+        const test = await chris.folder({ id: folderToShare.data.id });
+        await chris.deleteFolder({ id: folderToShare.data.id });
+        expect(test).not.toBeNull();
+        if (!test) {
+          throw new Error("empty or undefined value: test");
+        }
+
+        if (test.__typename === "ErrorAccessDenied") {
+          throw new Error("Access denied");
+        }
+
+        if (test.__typename === "SuccessResponse") {
+          const folderCreatedByraph = test.data.subfolders.find(
+            f => f.name === nameFolder
+          );
+          expect(folderCreatedByraph).not.toBeUndefined();
+          if (!folderCreatedByraph) {
+            throw new Error("empty or undefined value: folderCreatedByraph");
+          }
+          expect(folderCreatedByraph.name).toBe(nameFolder);
+
+          //delete sharing
+          const deleteSharing = await chris.deleteFolderSharing({
+            folderId: test.data.id,
+            userId: raphId
+          });
+          expect(deleteSharing).toStrictEqual({
+            __typename: "SuccessResponse",
+            data: true
+          });
+        }
+      }
+    }
+  }, 50000);
+
+  test("deleteFolder", async () => {
+    //root folder
+    const rootFolder = await chris.folder();
+    expect(rootFolder).not.toBeNull();
+    if (!rootFolder) {
+      throw new Error("empty or undefined value: rootFolder");
+    }
+    if (rootFolder.__typename === "ErrorAccessDenied") {
+      throw new Error("Access denied");
+    }
+    const cloudFolder = rootFolder.data.subfolders.find(
+      f => f.name === "cloud"
+    );
+    expect(cloudFolder).not.toBeUndefined();
+    if (!cloudFolder) {
+      throw new Error("empty or undefined value: cloudFolder");
+    }
+
+    // create folder
+    const name = "test_folder_to_delete";
+    const folderToDelete = await chris.createFolder({
+      name,
+      parentFolderId: cloudFolder.id
+    });
+
+    expect(folderToDelete).not.toBeNull();
+    if (!folderToDelete) {
+      throw new Error("empty or undefined value: folderToDelete");
+    }
+
+    if (folderToDelete.__typename !== "SuccessResponse") {
+      throw new Error("folderToDelete is not a SuccessResponse");
+    }
+
+    // test breadcrumb
+    expect(folderToDelete.data.breadcrumb.map(f => f.name)).toEqual([
+      name,
+      "cloud",
+      "root"
+    ]);
+
+    // delete folder
+    const deletedFolder = await chris.deleteFolder({
+      id: folderToDelete.data.id
+    });
+    expect(deletedFolder).toStrictEqual({
+      __typename: "SuccessResponse",
+      data: true
+    });
+    const folderDeleted = await chris.folder({
+      id: folderToDelete.data.id,
+      deleted: true
+    });
+    expect(folderDeleted).not.toBeNull();
+    if (!folderDeleted) {
+      throw new Error("empty or undefined value: folderDeleted");
+    }
+    if (folderDeleted.__typename === "ErrorAccessDenied") {
+      throw new Error("Access denied");
+    }
+    expect(folderDeleted.data.deletedAt).not.toBeNull();
+    const deletedFolders = await chris.deletedFolders();
+    if (!deletedFolders) {
+      throw new Error("empty or undefined value: deletedFolders");
+    }
+    if (deletedFolders.__typename === "ErrorAccessDenied") {
+      throw new Error("Access denied");
+    }
+    const folderDeletedByChris = deletedFolders.data.find(
+      f => f.id === folderToDelete.data.id
+    );
+    if (!folderDeletedByChris) {
+      throw new Error("empty or undefined value: folderDeletedByChris");
+    }
+    expect(folderDeletedByChris.name).toBe(folderToDelete.data.name);
+
+    //recover folder
+    const folderToRecover = await chris.recoverFolder({
+      id: folderDeleted.data.id
+    });
+
+    expect(folderToRecover).toStrictEqual({
+      __typename: "SuccessResponse",
+      data: true
+    });
+    const folderRecovered = await chris.folder({
+      id: folderDeleted.data.id
+    });
+
+    if (!folderRecovered) {
+      throw new Error("empty or undefined value: folderRecovered");
+    }
+    if (folderRecovered.__typename === "ErrorAccessDenied") {
+      throw new Error("Access denied");
+    }
+    expect(folderRecovered).not.toBeNull();
+    if (!folderRecovered) {
+      throw new Error("empty or undefined value: folderRecovered");
+    }
+    expect(folderRecovered.data.deletedAt).toBeNull();
+
+    // await expect(
+    //   raph.recoverFolder({ id: folderDeleted.id })
+    // ).rejects.toThrowError("Invalid plan");
+
+    //delete cloud trash
+    const deletedFolderCloudTrash = await chris.deleteFolderCloudTrash({
+      ids: [folderRecovered.data.id]
+    });
+    expect(deletedFolderCloudTrash).toBe(true);
+  }, 50000);
+
+  test("update folder", async () => {
+    //root folder
+    const rootFolder = await chris.folder();
+    expect(rootFolder).not.toBeNull();
+    if (!rootFolder) {
+      throw new Error("empty or undefined value: rootFolder");
+    }
+    if (rootFolder.__typename === "ErrorAccessDenied") {
+      throw new Error("Access denied");
+    }
+    const cloudFolder = rootFolder.data.subfolders.find(
+      f => f.name === "cloud"
+    );
+    expect(cloudFolder).not.toBeUndefined();
+    if (!cloudFolder) {
+      throw new Error("empty or undefined value: cloudFolder");
+    }
+
+    //create folder
+    const name = "test_folder_to_update";
+    const folderToUpdate = await chris.createFolder({
+      name,
+      parentFolderId: cloudFolder.id
+    });
+
+    expect(folderToUpdate).not.toBeNull();
+    if (!folderToUpdate) {
+      throw new Error("empty or undefined value: folderToUpdate");
+    }
+
+    if (folderToUpdate.__typename !== "SuccessResponse") {
+      throw new Error("folderToUpdate is not a SuccessResponse");
+    }
+
+    //update folder
+    const folderUpdated = await chris.updateFolder({
+      folderId: folderToUpdate.data.id,
+      name: "test_folder_updated"
+    });
+
+    expect(folderUpdated).not.toBeNull();
+    if (!folderUpdated) {
+      throw new Error("empty or undefined value: folderUpdated");
+    }
+
+    if (folderUpdated.__typename !== "SuccessResponse") {
+      throw new Error("folderToUpdate is not a SuccessResponse");
+    }
+
+    expect(folderUpdated.data.name).toBe("test_folder_updated");
+
+    //delete folder
+    const deletedFolder = await chris.deleteFolder({
+      id: folderToUpdate.data.id
+    });
+    expect(deletedFolder).toStrictEqual({
+      __typename: "SuccessResponse",
+      data: true
+    });
+    const deletedFolderCloudTrash = await chris.deleteFolderCloudTrash({
+      ids: [folderToUpdate.data.id]
+    });
+    expect(deletedFolderCloudTrash).toStrictEqual({
+      __typename: "SuccessResponse",
+      data: true
+    });
+  });
+});