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

package/__tests__/client/mail.test.ts

@@ -0,0 +1,476 @@
+import { raph, chris, chrisId, raphId } from "./utils.js";
+import { MailType } from "./../../src/zeus/index.js";
+import { setup } from "../../src/index.js";
+
+const mailSubject = "jest unitTest";
+
+beforeAll(setup);
+
+beforeAll(async () => {
+  await Promise.all([chris.emptyMailTrash(), raph.emptyMailTrash()]);
+});
+
+afterAll(async () => {
+  const reqRaphSentMails = await raph.sentMails();
+  if (!reqRaphSentMails) {
+    throw new Error("reqRaphSentMails not found");
+  }
+  if (reqRaphSentMails.__typename === "ErrorNotFound") {
+    throw new Error("Error: raph sentMails not found");
+  }
+  const sentMailsRaph = reqRaphSentMails.data.filter(
+    m => m.subject === mailSubject
+  );
+
+  const reqChrisSentMails = await chris.sentMails();
+  if (!reqChrisSentMails) {
+    throw new Error("reqChrisSentMails not found");
+  }
+  if (reqChrisSentMails.__typename === "ErrorNotFound") {
+    throw new Error("Error: chris sentMails not found");
+  }
+  const sentMailsChris = reqChrisSentMails.data.filter(
+    m => m.subject === mailSubject
+  );
+
+  const reqRaphReceivedMails = await raph.receivedMails();
+  if (!reqRaphReceivedMails) {
+    throw new Error("reqRaphReceivedMails not found");
+  }
+  if (reqRaphReceivedMails.__typename === "ErrorNotFound") {
+    throw new Error("Error: raph receivedMails not found");
+  }
+  const receivedMailsRaph = reqRaphReceivedMails.data.filter(
+    m => m.subject === mailSubject
+  );
+
+  const reqChrisReceivedMails = await chris.receivedMails();
+  if (!reqChrisReceivedMails) {
+    throw new Error("reqChrisReceivedMails not found");
+  }
+  if (reqChrisReceivedMails.__typename === "ErrorNotFound") {
+    throw new Error("Error: chris receivedMails not found");
+  }
+  const receivedMailsChris = reqChrisReceivedMails.data.filter(
+    m => m.subject === mailSubject
+  );
+
+  const chrisMails = [...sentMailsChris, ...receivedMailsChris].map(m =>
+    chris.deleteMail({ mailId: m.id })
+  );
+  const raphMails = [...sentMailsRaph, ...receivedMailsRaph].map(m =>
+    raph.deleteMail({ mailId: m.id })
+  );
+  await Promise.all([chrisMails, raphMails]);
+}, 50000);
+
+describe("SecrecyClient - mail", () => {
+  test("wrong mail", async () => {
+    //wrong mail
+    const mail = await raph.mail({
+      id: "id"
+    });
+    expect(mail).toBeNull();
+  });
+
+  test("search mail", async () => {
+    //create draft mail
+    const mail = await raph.createDraftMail({
+      body: "test",
+      subject: mailSubject,
+      files: [],
+      recipientsIds: [chrisId],
+      replyTo: null
+    });
+
+    expect(mail).not.toBeNull();
+    if (!mail) {
+      throw new Error("empty or undefined value: mail");
+    }
+
+    if (mail.__typename !== "SuccessResponse") {
+      throw new Error("mail is not a SuccessResponse");
+    }
+
+    //search for existing mail
+    const mailFound = await raph.mail({
+      id: mail.data.id
+    });
+    if (!mailFound) {
+      throw new Error("undefined value: mailFound");
+    }
+    expect(mailFound).not.toBeNull();
+
+    if (mailFound.__typename === "ErrorAccessDenied") {
+      throw new Error("mailFound: Access denied");
+    }
+
+    //delete draft mail
+    const deletedDraftMail = await raph.deleteDraftMail(
+      mailFound.data.mailIntegrityId
+    );
+    expect(deletedDraftMail).toStrictEqual({
+      __typename: "SuccessResponse",
+      data: true
+    });
+  });
+
+  test("create, send draft mail and delete send and received mail", async () => {
+    //create draft mail
+    const mail = await raph.createDraftMail({
+      body: "hello ceci est un test",
+      subject: mailSubject,
+      files: [],
+      recipientsIds: [chrisId],
+      replyTo: null
+    });
+    expect(mail).not.toBeNull();
+    if (!mail) {
+      throw new Error("empty or undefined value: mail");
+    }
+    if (mail.__typename !== "SuccessResponse") {
+      throw new Error("mail is not a SuccessResponse");
+    }
+
+    //search for previous created draftMail
+    const draftMails = await raph.draftMails();
+    if (!draftMails) {
+      throw new Error("undefined value: draftMails");
+    }
+    if (draftMails.__typename === "ErrorNotFound") {
+      throw new Error("draftMails: not found");
+    }
+    const draftMail = draftMails.data.find(m => m.id === mail.data.id);
+    if (!draftMail) {
+      throw new Error("undefined value: draftMail");
+    }
+    expect(draftMail).toStrictEqual(mail.data);
+
+    //send draft mail
+    const draftMailSent = await raph.sendDraftMail(
+      mail.data.mailIntegrityId,
+      null
+    );
+    expect(draftMailSent).toStrictEqual({
+      __typename: "SuccessResponse",
+      data: true
+    });
+  });
+
+  test("Create, update and delete draft mails", async () => {
+    //create draft mail
+    const mail = await raph.createDraftMail({
+      body: "hello ceci est un test c'est le numero 2",
+      subject: mailSubject,
+      files: [],
+      recipientsIds: [chrisId],
+      replyTo: null
+    });
+    expect(mail).not.toBeNull();
+    if (!mail) {
+      throw new Error("empty or undefined value: mail");
+    }
+    if (mail.__typename !== "SuccessResponse") {
+      throw new Error("mail is not a SuccessResponse");
+    }
+
+    //search for previous created draftMail
+    const draftMails = await raph.draftMails();
+    if (!draftMails) {
+      throw new Error("empty or undefined value: draftMails");
+    }
+    if (draftMails.__typename === "ErrorNotFound") {
+      throw new Error("draftMails: not found");
+    }
+    const draftMail = draftMails.data.find(m => m.id === mail.data.id);
+    if (!draftMail) {
+      throw new Error("empty or undefined value: draftMail");
+    }
+    expect(draftMail).toStrictEqual(mail.data);
+
+    //update draft mail
+    const mailUpdated = await raph.updateDraftMail(mail.data.mailIntegrityId, {
+      body: "hello ceci est un draft mail mis a jour",
+      subject: mailSubject,
+      files: [],
+      recipientsIds: [chrisId],
+      replyTo: null
+    });
+    expect(mailUpdated).not.toBeNull();
+    if (!mailUpdated) {
+      throw new Error("empty or undefined value: mailUpdated");
+    }
+    if (mailUpdated.__typename !== "SuccessResponse") {
+      throw new Error("mailUpdated is not a SuccessResponse");
+    }
+
+    expect(mailUpdated.data.body).toBe(
+      "hello ceci est un draft mail mis a jour"
+    );
+
+    //delete draft mail
+    const deletedDraftMail = await raph.deleteDraftMail(
+      mail.data.mailIntegrityId
+    );
+    expect(deletedDraftMail).toStrictEqual({
+      __typename: "SuccessResponse",
+      data: true
+    });
+  });
+
+  test("Create and send mail", async () => {
+    //create draftMail
+    const mail = await raph.createDraftMail({
+      body: "hello ceci est un test c'est le numero 3",
+      subject: mailSubject,
+      files: [],
+      recipientsIds: [chrisId],
+      replyTo: null
+    });
+    expect(mail).not.toBeNull();
+    if (!mail) {
+      throw new Error("empty or undefined value: mail");
+    }
+    if (mail.__typename !== "SuccessResponse") {
+      throw new Error("mail is not a SuccessResponse");
+    }
+
+    //send draft mail
+    const draftMailSent = await raph.sendDraftMail(
+      mail.data.mailIntegrityId,
+      null
+    );
+    expect(draftMailSent).not.toBeNull();
+    if (!draftMailSent) {
+      throw new Error("empty or undefined value: mail");
+    }
+    expect(draftMailSent.__typename).toBe("SuccessResponse");
+
+    //sent Mail
+    const sentMails = await raph.sentMails();
+    expect(sentMails).not.toBeNull();
+    if (!sentMails) {
+      throw new Error("empty or undefined value: sentMails");
+    }
+    if (sentMails.__typename !== "SuccessResponse") {
+      throw new Error("sentMails is not a SuccessResponse");
+    }
+    const mailSent = sentMails.data.find(m => m.id === mail.data.id);
+    if (!mailSent) {
+      throw new Error("empty or undefined value: mailSent");
+    }
+    expect(mailSent.id).toStrictEqual(mail.data.id);
+  });
+
+  test("Create and received mail", async () => {
+    //create draftMail
+    const mail = await chris.createDraftMail({
+      body: "test mail send from chris to raph",
+      subject: mailSubject,
+      files: [],
+      recipientsIds: [raphId],
+      replyTo: null
+    });
+    expect(mail).not.toBeNull();
+    if (!mail) {
+      throw new Error("empty or undefined value: mail");
+    }
+    if (mail.__typename !== "SuccessResponse") {
+      throw new Error("mail is not a SuccessResponse");
+    }
+
+    //send draft mail
+    const draftMailSent = await chris.sendDraftMail(
+      mail.data.mailIntegrityId,
+      null
+    );
+    expect(draftMailSent).not.toBeNull();
+    if (!draftMailSent) {
+      throw new Error("empty or undefined value: mail");
+    }
+    expect(draftMailSent.__typename).toBe("SuccessResponse");
+
+    //received Mail
+    const receivedMailsToDel = await raph.receivedMails();
+    if (!receivedMailsToDel) {
+      throw new Error("empty or undefined value: receivedMailsToDel");
+    }
+    if (receivedMailsToDel.__typename === "ErrorNotFound") {
+      throw new Error("receivedMails: not found");
+    }
+    const mailReceived = receivedMailsToDel.data.find(
+      m => m.body === mail.data.body
+    );
+    if (!mailReceived) {
+      throw new Error("empty or undefined value: mailReceived");
+    }
+    expect(mailReceived.body).toBe("test mail send from chris to raph");
+  });
+
+  test("read and unread mail", async () => {
+    //create draftMail
+    const mail = await chris.createDraftMail({
+      body: "read and unread test",
+      subject: mailSubject,
+      files: [],
+      recipientsIds: [raphId],
+      replyTo: null
+    });
+
+    expect(mail).not.toBeNull();
+    if (!mail) {
+      throw new Error("empty or undefined value: mail");
+    }
+
+    if (mail.__typename !== "SuccessResponse") {
+      throw new Error("mail is not a SuccessResponse");
+    }
+
+    //send draft mail
+    const draftMailSent = await chris.sendDraftMail(
+      mail.data.mailIntegrityId,
+      null
+    );
+    expect(draftMailSent).toStrictEqual({
+      __typename: "SuccessResponse",
+      data: true
+    });
+
+    //mail from chris
+    const receivedMails = await raph.receivedMails();
+    if (!receivedMails) {
+      throw new Error("empty or undefined value: receivedMails");
+    }
+    if (receivedMails.__typename === "ErrorNotFound") {
+      throw new Error("receivedMails: not found");
+    }
+    const mailReceived = receivedMails.data.find(
+      m => m.body === mail.data.body
+    );
+    if (!mailReceived) {
+      throw new Error("empty or undefined value: mailReceived");
+    }
+    expect(mailReceived.body).toBe("read and unread test");
+
+    //read mail
+    const readMail = await raph.readMail({ mailId: mailReceived.id });
+    expect(readMail).toStrictEqual({
+      __typename: "SuccessResponse",
+      data: true
+    });
+
+    //looker for mail opened
+    const mailReaded = await raph.mail({ id: mailReceived.id });
+    if (!mailReaded) {
+      throw new Error("empty or undefined value: mailReaded");
+    }
+    if (mailReaded.__typename === "ErrorAccessDenied") {
+      throw new Error("mailReaded: access denied");
+    }
+    expect(mailReaded.data.openedAt).not.toBeNull();
+
+    //unread mail
+    const unreadMail = await raph.unreadMail({ mailId: mailReceived.id });
+    expect(unreadMail).toStrictEqual({
+      __typename: "SuccessResponse",
+      data: true
+    });
+
+    //looker for mail unreaded
+    const mailUnread = await raph.mail({ id: mailReceived.id });
+    if (!mailUnread) {
+      throw new Error("empty or undefined value: mailUnread");
+    }
+    if (mailUnread.__typename === "ErrorAccessDenied") {
+      throw new Error("mailUnread: access denied");
+    }
+    expect(mailUnread.data.openedAt).toBeNull();
+  });
+
+  test("deletedMails", async () => {
+    //create draftMail
+    const mail = await raph.createDraftMail({
+      body: "hello ceci est un test c'est pour test les deletedMails",
+      subject: mailSubject,
+      files: [],
+      recipientsIds: [chrisId],
+      replyTo: null
+    });
+
+    expect(mail).not.toBeNull();
+    if (!mail) {
+      throw new Error("empty or undefined value: mail");
+    }
+
+    if (mail.__typename !== "SuccessResponse") {
+      throw new Error("mail is not a SuccessResponse");
+    }
+
+    //send draft mail
+    const draftMailSent = await raph.sendDraftMail(
+      mail.data.mailIntegrityId,
+      null
+    );
+    expect(draftMailSent).toStrictEqual({
+      __typename: "SuccessResponse",
+      data: true
+    });
+
+    //delete mail sent
+    //sent
+    const sentMailsRaph = await raph.sentMails();
+    if (!sentMailsRaph) {
+      throw new Error("empty or undefined value: sentMailsRaph");
+    }
+    if (sentMailsRaph.__typename === "ErrorNotFound") {
+      throw new Error("sentMails: not found");
+    }
+
+    for (const m of sentMailsRaph.data) {
+      if (m.subject === mailSubject) {
+        await raph.deleteMail({ mailId: m.id });
+      }
+    }
+
+    //deleted Mails
+    const deletedMails = await raph.deletedMails({ mailType: MailType.sent });
+    if (!deletedMails) {
+      throw new Error("empty or undefined value: deletedMails");
+    }
+    if (deletedMails.__typename === "ErrorAccessDenied") {
+      throw new Error("deletedMails: access denied");
+    }
+    expect(deletedMails.data[0].type).toBe(MailType.sent);
+    expect(deletedMails.data[0].deletedAt).not.toBeNull();
+  }, 50000);
+
+  test("unreadReceivedMailsCount", async () => {
+    const count = await raph.unreadReceivedMailsCount();
+
+    await chris.createMail({
+      body: "hello ceci est un test c'est pour test les unreadReceivedMailsCount",
+      subject: mailSubject,
+      files: [],
+      recipientsIds: [raphId],
+      replyTo: null
+    });
+
+    if (!count) {
+      throw new Error("empty or undefined value: count");
+    }
+
+    if (count.__typename === "ErrorAccessDenied") {
+      throw new Error("unreadReceivedMailsCount2: access denied");
+    }
+
+    const countTwo = await raph.unreadReceivedMailsCount();
+    if (!countTwo) {
+      throw new Error("empty or undefined value: count2");
+    }
+
+    if (countTwo.__typename === "ErrorAccessDenied") {
+      throw new Error("unreadReceivedMailsCount2: access denied");
+    }
+    expect(count.data + 1).toBe(countTwo.data);
+  });
+});

package/__tests__/client/timing.test.ts

@@ -0,0 +1,35 @@
+import { raph } from "./utils.js";
+import { setup } from "../../src/index.js";
+
+beforeAll(setup);
+
+describe("Testing Timer", () => {
+  test("Load Cloud", async () => {
+    const load = await raph.folder();
+    if (!load) {
+      return false;
+    }
+    return true;
+  }, 50000);
+  test("Load Sent Mails", async () => {
+    const load = await raph.sentMails();
+    if (!load) {
+      return false;
+    }
+    return true;
+  }, 50000);
+  test("Load Receive Mails", async () => {
+    const load = await raph.receivedMails();
+    if (!load) {
+      return false;
+    }
+    return true;
+  }, 50000);
+  test("Load Draft Mails", async () => {
+    const load = await raph.draftMails();
+    if (!load) {
+      return false;
+    }
+    return true;
+  }, 50000);
+});

package/__tests__/client/utils.ts

@@ -0,0 +1,41 @@
+import { SecrecyClient } from "../../src/index.js";
+
+export const chrisId = "ckudr5prq005801aznqly0rv2";
+export const axelId = "ckufkdt40004901293cxftrav";
+export const raphId = "ckxit9sbk6268901c1svzcvwzu";
+
+export const chris = new SecrecyClient(
+  "e11dfbe1ba291b5fc9d69c0922e7dd6a720e0a06257c41274c98b1b597851b75",
+  {
+    privateKey:
+      "dfe06b209231e07b85de05c2428b8fed7465c8c04b6b09fd10126643d229c6b1",
+    publicKey:
+      "27fb31855dba1e3466822dfe90e51455918d8c7934bf168816de93d922aaf705"
+  },
+  "eyJhbGciOiJIUzUxMiIsInR5cCI6IkpXVCJ9.eyJlbWFpbCI6ImNocmlzQHNlY3JlY3kubWUiLCJpYXQiOjE2MzM2MDU0ODksImV4cCI6MTYzNDIxMDI4OSwiYXVkIjoiaHR0cHM6Ly9hcHAuZGV2LnNlY3JlY3kubWUiLCJpc3MiOiJodHRwczovL2F1dGguc2VjcmVjeS5tZSIsInN1YiI6ImNrdWRyNmVlbjAxMjgwMWF6MzI4MXB1OHUifQ.9MuQJpLFhW2nSJA_S6svQttRxOreItOZ1876Lz-tRkjcGW6M6yLM0S5lsqrT0_DzDN1jxoRSyZA9nzfZoEnmdA",
+  "dev"
+);
+
+export const axel = new SecrecyClient(
+  "539dfe1e23b799c684ff5df0cfe52821f5debfc2cdb81da999e6a26b003e8651",
+  {
+    privateKey:
+      "fd7b5a72b6f71094782a6b744bff8f0d061a32c4dcca0f0efb3c91b78ccf244f",
+    publicKey:
+      "00f97b35ce49815202107cd4ce7831dfb00d6ec8cafd25fb06b4e2ef1a475404"
+  },
+  "eyJhbGciOiJIUzUxMiIsInR5cCI6IkpXVCJ9.eyJlbWFpbCI6ImF4ZWwubGF2b2llQGdtYWlsLmNvbSIsImlhdCI6MTYzMzYwNTQ0MCwiZXhwIjoxNjM0MjEwMjQwLCJhdWQiOiJodHRwczovL2FwcC5kZXYuc2VjcmVjeS5tZSIsImlzcyI6Imh0dHBzOi8vYXV0aC5zZWNyZWN5Lm1lIiwic3ViIjoiY2t1Zmtkdm50MDEwNzAxMjk5a2ZqanpxcyJ9.XqFB7oXCqNYAlW9uP919i8rdvJjZ5AZAda76fr_9x2d5ScImVzGm6ALiG5tb8lIt804aRaJ_qAVaQdikoSG2-Q",
+  "dev"
+);
+
+export const raph = new SecrecyClient(
+  "a10db5cedd6096713ef44c4f98d62c698513cf4e77a20945e528d7cdedd6c6e2",
+  {
+    privateKey:
+      "7673fa7c534987ae69dc6d7c85458133afb03e2d2c43c3a5982d1abb04c7fbdc",
+    publicKey:
+      "113fd1991579d5e787ea9e8ce8ec944df930586e5a04af04e9ef4971e087c04e"
+  },
+  "eyJhbGciOiJIUzUxMiIsInR5cCI6IkpXVCJ9.eyJlbWFpbCI6InJhcGhhZWxtb3J0aWVyQG91dGxvb2suZnIiLCJpYXQiOjE2NDA4NzIyNjcsImV4cCI6MTY0MTQ3NzA2NywiYXVkIjoiaHR0cHM6Ly9hcHAuZGV2LnNlY3JlY3kubWUiLCJpc3MiOiJodHRwczovL2F1dGguc2VjcmVjeS5tZSIsInN1YiI6ImNreGl0YmEzcjYyNzc3MDFjMTJqM2J4Y2cwIn0.mKZVKRSxVMOy6uuTFyxJuz2tH2MWpjQZEzjbny5ScwMYdexjnkGCy1EkHX-iZ-SdcOUQkk39buIl_W1kIFQQKg",
+  "dev"
+);