working v1

tests/controller/user-controller.test.js

@@ -0,0 +1,422 @@
+const request = require("supertest");
+const app = require("../utils/express-app");
+const mongoose = require("mongoose");
+const { MongoMemoryServer } = require("mongodb-memory-server");
+const getEnvVariables = require("../../dist-backend/enviroment/get-env-variables");
+const getKey = require("../../dist-backend/key/get-key").default;
+getEnvVariables();
+const env = require("../../dist-backend/enviroment/env");
+const { envFileFix } = require("../utils/db-setup");
+const { ObjectId } = require("mongodb");
+
+let mongoServer;
+let authToken;
+let authToken2;
+let user;
+let user2;
+
+describe("File Controller", () => {
+  beforeAll(async () => {
+    envFileFix(env);
+    await getKey();
+    mongoServer = await MongoMemoryServer.create();
+    await mongoose.connect(mongoServer.getUri(), { useNewUrlParser: true });
+  });
+
+  beforeEach(async () => {
+    await mongoose.model("fs.files").deleteMany({});
+    await mongoose.model("Folder").deleteMany({});
+    await mongoose.model("User").deleteMany({});
+    envFileFix(env);
+
+    user = await request(app)
+      .post("/user-service/create")
+      .send({
+        email: "test@test.com",
+        password: "test1234",
+      })
+      .set("uuid", 12314123123);
+
+    user2 = await request(app)
+      .post("/user-service/create")
+      .send({
+        email: "test@test2.com",
+        password: "test1234",
+      })
+      .set("uuid", 12314123124);
+
+    authToken = user.headers["set-cookie"]
+      .map((cookie) => cookie.split(";")[0])
+      .join("; ");
+
+    authToken2 = user2.headers["set-cookie"]
+      .map((cookie) => cookie.split(";")[0])
+      .join("; ");
+  });
+
+  afterAll(async () => {
+    await mongoose.disconnect();
+    await mongoServer.stop();
+  });
+
+  describe("User info: GET /user-service/user", () => {
+    test("Should return user info", async () => {
+      const userResponse = await request(app)
+        .get(`/user-service/user`)
+        .set("Cookie", authToken);
+
+      expect(userResponse.status).toBe(200);
+      expect(userResponse.body.email).toBe(user.body.user.email);
+    });
+    test("Should return 401 if not authorized", async () => {
+      const userResponse = await request(app)
+        .get(`/user-service/user`)
+        .set("Cookie", "access-token=test");
+
+      expect(userResponse.status).toBe(401);
+    });
+  });
+
+  describe("User login: POST /user-service/login", () => {
+    test("Should login user", async () => {
+      const userResponse = await request(app).post("/user-service/login").send({
+        email: user.body.user.email,
+        password: "test1234",
+      });
+
+      expect(userResponse.status).toBe(200);
+      expect(userResponse.body.user.email).toBe(user.body.user.email);
+    });
+    test("Should return 401 if incorrect password", async () => {
+      const userResponse = await request(app).post("/user-service/login").send({
+        email: user.body.user.email,
+        password: "test12345",
+      });
+
+      expect(userResponse.status).toBe(401);
+    });
+    test("Should return 401 if incorrect email", async () => {
+      const userResponse = await request(app).post("/user-service/login").send({
+        email: "notexist@test.com",
+        password: "test1234",
+      });
+      expect(userResponse.status).toBe(401);
+    });
+    test("Should return 400 if email length is less than 3", async () => {
+      const userResponse = await request(app).post("/user-service/login").send({
+        email: "ab",
+        password: "test1234",
+      });
+
+      expect(userResponse.status).toBe(400);
+    });
+    test("Should return 400 if email length is greater than 320", async () => {
+      const userResponse = await request(app)
+        .post("/user-service/login")
+        .send({
+          email: "a".repeat(321) + "@test.com",
+          password: "test1234",
+        });
+
+      expect(userResponse.status).toBe(400);
+    });
+    test("Should return 400 if email address is invalid", async () => {
+      const userResponse = await request(app).post("/user-service/login").send({
+        email: "a@b",
+        password: "test1234",
+      });
+
+      expect(userResponse.status).toBe(400);
+    });
+    test("Should return 400 if password length is less than 6", async () => {
+      const userResponse = await request(app).post("/user-service/login").send({
+        email: "test@test.com",
+        password: "a",
+      });
+
+      expect(userResponse.status).toBe(400);
+    });
+    test("Should return 400 if password length is greater than 256", async () => {
+      const userResponse = await request(app)
+        .post("/user-service/login")
+        .send({
+          email: "test@test.com",
+          password: "a".repeat(257),
+        });
+
+      expect(userResponse.status).toBe(400);
+    });
+  });
+
+  describe("Create User: POST /user-service/create", () => {
+    test("Should create user", async () => {
+      const userResponse = await request(app)
+        .post("/user-service/create")
+        .send({
+          email: "newuser@test.com",
+          password: "test1234",
+        });
+
+      expect(userResponse.status).toBe(201);
+
+      const userDbCheck = await mongoose.model("User").findOne({
+        _id: userResponse.body.user._id,
+      });
+
+      expect(userDbCheck.email).toBe(userResponse.body.user.email);
+    });
+    test("Should return 400 if no email", async () => {
+      const userResponse = await request(app)
+        .post("/user-service/create")
+        .send({
+          password: "test1234",
+        });
+
+      expect(userResponse.status).toBe(400);
+    });
+    test("Should return 400 if no password", async () => {
+      const userResponse = await request(app)
+        .post("/user-service/create")
+        .send({
+          email: "newuser@test.com",
+        });
+
+      expect(userResponse.status).toBe(400);
+    });
+    test("Should return 400 if email length is less than 3", async () => {
+      const userResponse = await request(app)
+        .post("/user-service/create")
+        .send({
+          email: "a@b",
+          password: "test1234",
+        });
+
+      expect(userResponse.status).toBe(400);
+    });
+    test("Should return 400 if email length is greater than 320", async () => {
+      const userResponse = await request(app)
+        .post("/user-service/create")
+        .send({
+          email: "a".repeat(321) + "@test.com",
+          password: "test1234",
+        });
+
+      expect(userResponse.status).toBe(400);
+    });
+    test("Should return 400 if password length is less than 6", async () => {
+      const userResponse = await request(app)
+        .post("/user-service/create")
+        .send({
+          email: "newuser@test.com",
+          password: "",
+        });
+
+      expect(userResponse.status).toBe(400);
+    });
+    test("Should return 400 if password length is greater than 256", async () => {
+      const userResponse = await request(app)
+        .post("/user-service/create")
+        .send({
+          email: "newuser@test.com",
+          password: "a".repeat(267),
+        });
+
+      expect(userResponse.status).toBe(400);
+    });
+    test("Should return 409 if email already exists", async () => {
+      const userResponse = await request(app)
+        .post("/user-service/create")
+        .send({
+          email: "test@test.com",
+          password: "test1234",
+        });
+
+      expect(userResponse.status).toBe(409);
+    });
+    test("Should return 403 if create account is blocked", async () => {
+      env.createAcctBlocked = true;
+
+      const userResponse = await request(app)
+        .post("/user-service/create")
+        .send({
+          email: "newemail@test.com",
+          password: "test1234",
+        });
+
+      expect(userResponse.status).toBe(403);
+    });
+  });
+
+  describe("Change Password: PATCH /user-service/change-password", () => {
+    test("Should change password", async () => {
+      const changePasswordResponse = await request(app)
+        .patch("/user-service/change-password")
+        .set("Cookie", authToken)
+        .send({
+          oldPassword: "test1234",
+          newPassword: "test12345",
+        });
+      expect(changePasswordResponse.status).toBe(200);
+      const loginResponse = await request(app)
+        .post("/user-service/login")
+        .send({
+          email: user.body.user.email,
+          password: "test12345",
+        });
+      expect(loginResponse.status).toBe(200);
+    });
+    test("Should return 401 if not authorized", async () => {
+      const changePasswordResponse = await request(app)
+        .patch("/user-service/change-password")
+        .set("Cookie", "access-token=test")
+        .send({
+          oldPassword: "test1234",
+          newPassword: "test12345",
+        });
+      expect(changePasswordResponse.status).toBe(401);
+    });
+    test("Should return 401 if incorrect password", async () => {
+      const changePasswordResponse = await request(app)
+        .patch("/user-service/change-password")
+        .set("Cookie", authToken)
+        .send({
+          oldPassword: "test12345",
+          newPassword: "test1234",
+        });
+      expect(changePasswordResponse.status).toBe(401);
+    });
+    test("Should return 400 if no old password", async () => {
+      const changePasswordResponse = await request(app)
+        .patch("/user-service/change-password")
+        .set("Cookie", authToken)
+        .send({
+          newPassword: "test12345",
+        });
+      expect(changePasswordResponse.status).toBe(400);
+    });
+    test("Should return 400 if no new password", async () => {
+      const changePasswordResponse = await request(app)
+        .patch("/user-service/change-password")
+        .set("Cookie", authToken)
+        .send({
+          oldPassword: "test1234",
+        });
+      expect(changePasswordResponse.status).toBe(400);
+    });
+    test("Should return 400 if old password length is less than 6", async () => {
+      const changePasswordResponse = await request(app)
+        .patch("/user-service/change-password")
+        .set("Cookie", authToken)
+        .send({
+          oldPassword: "",
+          newPassword: "test12345",
+        });
+      expect(changePasswordResponse.status).toBe(400);
+    });
+    test("Should return 400 if old password length is greater than 256", async () => {
+      const changePasswordResponse = await request(app)
+        .patch("/user-service/change-password")
+        .set("Cookie", authToken)
+        .send({
+          oldPassword: "a".repeat(257),
+          newPassword: "test12345",
+        });
+      expect(changePasswordResponse.status).toBe(400);
+    });
+    test("Should return 400 if new password length is less than 6", async () => {
+      const changePasswordResponse = await request(app)
+        .patch("/user-service/change-password")
+        .set("Cookie", authToken)
+        .send({
+          oldPassword: "test1234",
+          newPassword: "",
+        });
+      expect(changePasswordResponse.status).toBe(400);
+    });
+    test("Should return 400 if new password length is greater than 256", async () => {
+      const changePasswordResponse = await request(app)
+        .patch("/user-service/change-password")
+        .set("Cookie", authToken)
+        .send({
+          oldPassword: "test1234",
+          newPassword: "a".repeat(257),
+        });
+      expect(changePasswordResponse.status).toBe(400);
+    });
+  });
+
+  describe("Get/Create user token: POST /user-service/get-token", () => {
+    test("Should return user token", async () => {
+      const getTokenResponse = await request(app)
+        .post("/user-service/get-token")
+        .set("Cookie", authToken)
+        .send();
+
+      expect(getTokenResponse.status).toBe(201);
+    });
+    test("Should return 401 if not authorized", async () => {
+      const getTokenResponse = await request(app)
+        .post("/user-service/get-token")
+        .set("Cookie", "access-token=test")
+        .send();
+
+      expect(getTokenResponse.status).toBe(401);
+    });
+  });
+
+  describe("Logout: POST /user-service/logout", () => {
+    test("Should logout user", async () => {
+      const userDbCheck = await mongoose.model("User").findOne({
+        email: user.body.user.email,
+      });
+
+      expect(userDbCheck.tokens.length).toBe(1);
+
+      const logoutResponse = await request(app)
+        .post("/user-service/logout")
+        .set("Cookie", authToken)
+        .send();
+
+      const userDbCheck2 = await mongoose.model("User").findOne({
+        email: user.body.user.email,
+      });
+
+      expect(userDbCheck2.tokens.length).toBe(0);
+      expect(logoutResponse.status).toBe(200);
+    });
+    test("Should return 401 if not authorized", async () => {
+      const logoutResponse = await request(app)
+        .post("/user-service/logout")
+        .set("Cookie", "access-token=test")
+        .send();
+
+      expect(logoutResponse.status).toBe(401);
+    });
+  });
+  describe("Logout all: POST /user-service/logout-all", () => {
+    test("Should logout all users", async () => {
+      await request(app).post("/user-service/login").send({
+        email: user.body.user.email,
+        password: "test1234",
+      });
+
+      const userDbCheck = await mongoose.model("User").findOne({
+        email: user.body.user.email,
+      });
+
+      expect(userDbCheck.tokens.length).toBe(2);
+
+      const logoutAllResponse = await request(app)
+        .post("/user-service/logout-all")
+        .set("Cookie", authToken)
+        .send();
+
+      const userDbCheck2 = await mongoose.model("User").findOne({
+        email: user.body.user.email,
+      });
+
+      expect(userDbCheck2.tokens.length).toBe(0);
+      expect(logoutAllResponse.status).toBe(200);
+    });
+  });
+});

tests/utils/db-setup.js

@@ -0,0 +1,49 @@
+const createTestData = (mongoose) => {
+  const file = new mongoose.model("fs.files");
+
+  file.create({
+    name: "test.txt",
+    type: "text/plain",
+    size: 10,
+    userId: "5f7e5d8d1f962d5a0f5e8a9e",
+  });
+};
+
+const envFileFix = (env) => {
+  env.key = process.env.KEY;
+  env.newKey = process.env.NEW_KEY;
+  env.passwordAccess = process.env.PASSWORD_ACCESS;
+  env.passwordRefresh = process.env.PASSWORD_REFRESH;
+  env.passwordCookie = process.env.PASSWORD_COOKIE;
+  env.createAcctBlocked = process.env.BLOCK_CREATE_ACCOUNT;
+  env.root = process.env.ROOT;
+  env.url = process.env.URL;
+  env.mongoURL = process.env.MONGODB_URL;
+  env.dbType = process.env.DB_TYPE;
+  env.fsDirectory = process.env.FS_DIRECTORY;
+  env.s3ID = process.env.S3_ID;
+  env.s3Key = process.env.S3_KEY;
+  env.s3Bucket = process.env.S3_BUCKET;
+  env.useDocumentDB = process.env.USE_DOCUMENT_DB;
+  env.documentDBBundle = process.env.DOCUMENT_DB_BUNDLE;
+  env.sendgridKey = process.env.SENDGRID_KEY;
+  env.sendgridEmail = process.env.SENDGRID_EMAIL;
+  env.remoteURL = process.env.REMOTE_URL;
+  env.secureCookies = process.env.SECURE_COOKIES;
+  env.tempDirectory = process.env.TEMP_DIRECTORY;
+  env.emailVerification = process.env.EMAIL_VERIFICATION;
+  env.emailDomain = process.env.EMAIL_DOMAIN;
+  env.emailAPIKey = process.env.EMAIL_API_KEY;
+  env.emailHost = process.env.EMAIL_HOST;
+  env.emailPort = process.env.EMAIL_PORT;
+  env.emailAddress = process.env.EMAIL_ADDRESS;
+  env.videoThumbnailsEnabled = process.env.VIDEO_THUMBNAILS_ENABLED === "true";
+  env.tempVideoThumbnailLimit = process.env.TEMP_VIDEO_THUMBNAIL_LIMIT
+    ? +process.env.TEMP_VIDEO_THUMBNAIL_LIMIT
+    : 0;
+  env.docker = process.env.DOCKER === "true";
+};
+
+module.exports = {
+  envFileFix,
+};

tests/utils/express-app.js

@@ -0,0 +1,49 @@
+const express = require("express");
+// const requestIp = require("request-ip");
+const bodyParser = require("body-parser");
+const cookieParser = require("cookie-parser");
+const helmet = require("helmet");
+const compression = require("compression");
+const busboy = require("connect-busboy");
+const userRouter =
+  require("../../dist-backend/express-routers/user-router").default;
+const fileRouter =
+  require("../../dist-backend/express-routers/file-router").default;
+const folderRouter =
+  require("../../dist-backend/express-routers/folder-router").default;
+const env = require("../../dist-backend/enviroment/env");
+const middlewareErrorHandler =
+  require("../../dist-backend/middleware/utils/middleware-utils").middlewareErrorHandler;
+const getEnviromentVariables = require("../../dist-backend/enviroment/get-env-variables");
+
+process.env.NODE_ENV = "test";
+
+getEnviromentVariables();
+
+const app = express();
+
+app.use(cookieParser(env.passwordCookie));
+app.use(helmet());
+app.use(compression());
+app.use(express.json());
+app.use(bodyParser.json({ limit: "50mb" }));
+app.use(
+  bodyParser.urlencoded({
+    limit: "50mb",
+    extended: true,
+    parameterLimit: 50000,
+  })
+);
+// app.use(requestIp.mw());
+
+app.use(
+  busboy({
+    highWaterMark: 2 * 1024 * 1024,
+  })
+);
+
+app.use(userRouter, fileRouter, folderRouter);
+
+app.use(middlewareErrorHandler);
+
+module.exports = app;

tests/utils/fileUtils.js

@@ -0,0 +1,15 @@
+// const createFolderTree = async (request, app, token) => {
+//   const rootFolderResponse = await request(app)
+//     .post("/folder-service/create")
+//     .set("Cookie", authToken)
+//     .send({
+//       name: "test",
+//       parent: "/",
+//     });
+
+//     expect(rootFolderResponse.status).toBe(201);
+
+//     const rootFolderId = rootFolderResponse.body._id;
+
+//     const folder2Response =
+// };