[DNM] closes #232 - Arango functions to stop/start server, and create/delete account

database/arango/arango.js

@@ -0,0 +1,95 @@
+require("dotenv").config();
+const { Database } = require("arangojs");
+const { sendFetch } = require("../../lib/sendFetch");
+const logger = require("./../../lib/log")(__filename);
+
+const arangoModule = {};
+let db;
+
+arangoModule.checkIfDatabaseExists = async (name) => {
+  // returns array of objects containing a '_name' key.
+  // Ex [{ _name: 'lol' }, { _name: 'cakes' }]
+  const names = await db.databases();
+  return names.map((db) => db._name).includes(name);
+};
+
+arangoModule.startArangoDB = async () => {
+  try {
+    db = new Database({
+      url: process.env.ARANGO_URL,
+      databaseName: "_system",
+      auth: {
+        username: process.env.ARANGO_USER,
+        password: process.env.ARANGO_PW,
+      },
+    });
+    logger.info("Connected to Arango Database");
+  } catch (err) {
+    logger.error(err);
+    throw new Error("Error in connecting to Arango Database", err);
+  }
+};
+
+arangoModule.closeArangoDB = () => {
+  try {
+    db.close();
+    logger.info("Successful closing of connection to Arango database");
+  } catch (err) {
+    logger.error(err);
+    throw new Error("Error closing Arango database", err);
+  }
+};
+
+arangoModule.createAccount = async (account) => {
+  if (!account) return;
+  const { username, dbPassword } = account;
+  if (!username || !dbPassword) return;
+  if (await arangoModule.checkIfDatabaseExists(username)) return;
+
+  try {
+    await db.createDatabase(username, {
+      users: [{ username, password: dbPassword }],
+    });
+    logger.info(`Successfully created Arango user and database ${username}`);
+  } catch (err) {
+    logger.error(err);
+    throw new Error("Error in creating arango database :(", err);
+  }
+};
+
+arangoModule.deleteAccount = async (username) => {
+  if (!username) return;
+  if (!(await arangoModule.checkIfDatabaseExists(username))) return;
+
+  try {
+    // grabs JWT token for use in second fetch
+    const {
+      jwt,
+    } = await sendFetch(
+      `${process.env.ARANGO_URL}_db/_system/_open/auth`,
+      "post",
+      { username: process.env.ARANGO_USER, password: process.env.ARANGO_PW }
+    );
+
+    // uses jwt token to authenticate request to delete user from arango database
+    await sendFetch(
+      `${process.env.ARANGO_URL}_db/_system/_api/user/${username}`,
+      "delete",
+      null,
+      `bearer ${jwt}`
+    );
+
+    logger.info(`Successfully deleted Arango user ${username}`);
+    // deletes database(username and database names are the same for each user)
+    await db.dropDatabase(username);
+    logger.info(`Successfully deleted Arango database ${username}`);
+  } catch (err) {
+    logger.error(err);
+    throw new Error(
+      "Sum ting wong... deletion of arango user has failed.",
+      err
+    );
+  }
+};
+
+module.exports = arangoModule;

database/arango/arango.test.js

@@ -0,0 +1,129 @@
+jest.mock("arangojs");
+jest.mock("../../lib/sendFetch");
+const { sendFetch } = require("../../lib/sendFetch");
+const Arango = require("arangojs");
+jest.mock("../../lib/log");
+const logGen = require("../../lib/log");
+const logger = {
+  info: jest.fn(),
+  error: jest.fn(),
+};
+logGen.mockReturnValue(logger);
+jest.mock("dotenv");
+Arango.Database = jest.fn().mockReturnValue({
+  close: jest.fn(),
+  createDatabase: jest.fn(),
+});
+
+const {
+  startArangoDB,
+  closeArangoDB,
+  createAccount,
+  deleteAccount,
+  checkIfDatabaseExists,
+} = require("./arango");
+
+describe("ArangoDB functions", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test("should call Database function", () => {
+    startArangoDB();
+    expect(Arango.Database).toHaveBeenCalledTimes(1);
+  });
+
+  test("should retun false", async () => {
+    const db = new Arango.Database();
+    db.databases = jest.fn().mockReturnValue([{ _name: "lol" }]);
+    const res = await checkIfDatabaseExists("hi");
+    expect(res).toEqual(false);
+  });
+
+  test("should retun true", async () => {
+    const db = new Arango.Database();
+    db.databases = jest.fn().mockReturnValue([{ _name: "lol" }]);
+    const res = await checkIfDatabaseExists("lol");
+    expect(res).toEqual(true);
+  });
+
+  test("should call db.close function", () => {
+    const db = new Arango.Database();
+    closeArangoDB();
+    expect(db.close).toHaveBeenCalledTimes(1);
+  });
+
+  test("should call db.close function and log error", () => {
+    const db = new Arango.Database();
+    db.close = jest.fn().mockImplementation(() => {
+      throw new Error();
+    });
+    try {
+      closeArangoDB();
+    } catch (err) {}
+    expect(db.close).toHaveBeenCalledTimes(1);
+    expect(logger.error).toHaveBeenCalledTimes(1);
+  });
+
+  test("should call db.createDatabase function, logger.error when theres an \
+  error, and do nothing if argument is invalid", async () => {
+    const db = new Arango.Database();
+    await createAccount();
+    expect(db.createDatabase).toHaveBeenCalledTimes(0);
+    expect(logger.error).toHaveBeenCalledTimes(0);
+
+    db.databases = jest.fn().mockReturnValue([{ _name: "lol" }]);
+    await createAccount({ username: "lol", dbPassword: "hi" });
+    expect(db.createDatabase).toHaveBeenCalledTimes(0);
+
+    db.databases = jest.fn().mockReturnValue([{ _name: "lol" }]);
+    await createAccount({ username: "", dbPassword: "" });
+    expect(db.createDatabase).toHaveBeenCalledTimes(0);
+
+    try {
+      db.databases = jest.fn().mockReturnValue([{ _name: "lol" }]);
+      await createAccount({ username: "hi", dbPassword: "hi" });
+      expect(db.createDatabase).toHaveBeenCalledTimes(1);
+
+      db.createDatabase = jest.fn().mockImplementation(() => {
+        throw new Error();
+      });
+      await createAccount({ username: "hi", dbPassword: "hi" });
+    } catch (err) {}
+    expect(logger.error).toHaveBeenCalledTimes(1);
+  });
+
+  test("should send two fetch requests if successful, logger.error when theres \
+  an error, and do nothing if argument is invalid", async () => {
+    const db = new Arango.Database();
+    await deleteAccount();
+    expect(sendFetch).toHaveBeenCalledTimes(0);
+    expect(logger.error).toHaveBeenCalledTimes(0);
+
+    db.databases = jest.fn().mockReturnValue([{ _name: "lol" }]);
+    sendFetch.mockReturnValue({ jwt: "lol" });
+    await deleteAccount("hi");
+    expect(sendFetch).toHaveBeenCalledTimes(0);
+
+    db.dropDatabase = jest.fn().mockReturnValue("lol");
+    await deleteAccount("lol");
+    expect(sendFetch).toHaveBeenCalledTimes(2);
+    expect(db.dropDatabase).toHaveBeenCalledTimes(1);
+
+    try {
+      sendFetch.mockImplementation(() => {
+        throw new Error();
+      });
+      await deleteAccount("lol");
+    } catch (err) {}
+    expect(logger.error).toHaveBeenCalledTimes(1);
+  });
+
+  test("should call Database function and FAIL", () => {
+    Arango.Database.mockImplementation(() => {
+      throw new Error();
+    });
+    startArangoDB();
+    expect(logger.error).toHaveBeenCalledTimes(1);
+  });
+});

database/elasticsearch/elastic.js

@@ -1,35 +1,20 @@
-const fetch = require("node-fetch");
 const logger = require("./../../lib/log")(__filename);
 require("dotenv").config();
-
+const { sendFetch } = require("../../lib/sendFetch");
 const es = {};
 
 const ES_HOST = process.env.ES_HOST || "http://127.0.0.1:9200";
 const authorization =
   "Basic " +
   Buffer.from(`elastic:${process.env.ES_PASSWORD}`).toString("base64");
 
-const sendESRequest = (path, method, body) => {
-  const options = {
-    method,
-    headers: {
-      Authorization: authorization,
-      "content-type": "application/json",
-    },
-  };
-  if (body) {
-    options.body = JSON.stringify(body);
-  }
-  return fetch(`${ES_HOST}${path}`, options).then((r) => r.json());
-};
-
 es.createAccount = async (account) => {
   if (!account.username || !account.dbPassword) {
     logger.error("Account data is invalid");
     throw new Error("Account data is invalid");
   }
-  const r1 = await sendESRequest(
-    `/_security/role/${account.username}`,
+  const r1 = await sendFetch(
+    `${ES_HOST}/_security/role/${account.username}`,
     "POST",
     {
       indices: [
@@ -38,21 +23,28 @@ es.createAccount = async (account) => {
           privileges: ["all"],
         },
       ],
-    }
+    },
+    authorization
   );
-  const r2 = await sendESRequest(
-    `/_security/user/${account.username}`,
+  const r2 = await sendFetch(
+    `${ES_HOST}/_security/user/${account.username}`,
     "POST",
     {
       email: account.email,
       password: account.dbPassword,
       roles: [account.username],
-    }
+    },
+    authorization
+  );
+  const r3 = await sendFetch(
+    `${ES_HOST}/${account.username}-example/_doc`,
+    "POST",
+    {
+      message:
+        "Congratulations! You have created your first index at Elasticsearch!",
+    },
+    authorization
   );
-  const r3 = await sendESRequest(`/${account.username}-example/_doc`, "POST", {
-    message:
-      "Congratulations! You have created your first index at Elasticsearch!",
-  });
   const err = r1.error || r2.error || r3.error;
   if (err) {
     logger.error(err);
@@ -75,15 +67,19 @@ es.deleteAccount = async (account) => {
     logger.error("Account data is invalid");
     throw new Error("Account data is invalid");
   }
-  const r1 = await sendESRequest(
-    `/_security/user/${account.username}`,
-    "DELETE"
+  const r1 = await sendFetch(
+    `${ES_HOST}/_security/user/${account.username}`,
+    "DELETE",
+    null,
+    authorization
   );
-  const r2 = await sendESRequest(
-    `/_security/role/${account.username}`,
-    "DELETE"
+  const r2 = await sendFetch(
+    `${ES_HOST}/_security/role/${account.username}`,
+    "DELETE",
+    null,
+    authorization
   );
-  const r3 = await sendESRequest(`/${account.username}-*`, "DELETE");
+  const r3 = await sendFetch(`/${account.username}-*`, "DELETE", null, authorization);
   const err = r1.error || r2.error;
   if (err || !r1.found || !r2.found) {
     logger.error("Deleting Elasticsearch user failed");
@@ -100,7 +96,8 @@ es.checkAccount = async (account) => {
     logger.error("Account data is invalid");
     throw new Error("Account data is invalid");
   }
-  const r1 = await sendESRequest(`/_security/user/${username}`, "GET");
+
+  const r1 = await sendFetch(`${ES_HOST}/_security/user/${username}`, "GET", null, authorization);
   logger.info(
     `Checking Elasticsearch account for ${username} result:`,
     !!r1[username]