Merge pull request #80 from AppQuality/develop

release-2022-07-11-CP-2173

src/__mocks__/globalSetup.ts

@@ -13,6 +13,8 @@ import CampaignAdditionals from "./mockedDb/campaignAdditionals";
 import CampaignMeta from "./mockedDb/campaignMeta";
 import UseCaseGroups from "./mockedDb/usecasesGroups";
 import UseCases from "./mockedDb/usecases";
+import UploadedMedia from "@src/__mocks__/mockedDb/uploadedMedia";
+
 import { table as bugAdditionalFields } from "@src/__mocks__/mockedDb/bugHasAdditionalFields";
 import { table as levelDefTable } from "@src/__mocks__/mockedDb/levelsDefinition";
 import { table as bugTable } from "./mockedDb/bug";
@@ -78,7 +80,6 @@ beforeAll(async () => {
   await CustomBugTypes.mock();
   await bugStatus.create();
   await bugAdditionalFields.create();
-
   await paymentRequestTable.create();
   await sqlite3.run(`
   CREATE TRIGGER "on_update__update_date"
@@ -96,4 +97,5 @@ beforeAll(async () => {
   await UseCaseGroups.mock();
   await Attributions.mock();
   await bugMedia.mock();
+  await UploadedMedia.mock();
 });

src/__mocks__/mockedDb/testerCertification.ts

@@ -3,12 +3,14 @@ import sqlite3 from "@src/features/sqlite";
 const tableName = "wp_appq_profile_certifications";
 export const table = {
   create: async () => {
-    await sqlite3.createTable(tableName, [
-      "id INTEGER PRIMARY KEY",
-      "tester_id INTEGER",
-      "cert_id INTEGER",
-      "achievement_date TIMESTAMP",
-    ]);
+    await sqlite3.run(`
+    CREATE TABLE ${tableName} (
+      id INTEGER PRIMARY KEY,
+      tester_id INTEGER,
+      cert_id INTEGER,
+      achievement_date TIMESTAMP,
+      UNIQUE( tester_id, cert_id )
+    )`);
   },
   drop: async () => {
     await sqlite3.dropTable(tableName);

src/__mocks__/mockedDb/uploadedMedia.ts

@@ -0,0 +1,26 @@
+import Table from "./table";
+
+type UploadedMediaParams = {
+  id?: number;
+  url?: string;
+  creation_date?: string;
+};
+const defaultItem: UploadedMediaParams = {
+  id: 1,
+  url: "www.exaple.com/media1.jpg",
+  creation_date: "2020-01-01 00:00:00",
+};
+class UploadedMedia extends Table<UploadedMediaParams> {
+  protected name = "wp_appq_uploaded_media";
+  protected columns = [
+    "id INTEGER PRIMARY KEY",
+    "url VARCHAR(255) NOT NULL",
+    "creation_date DATETIME NOT NULL",
+  ];
+  constructor() {
+    super(defaultItem);
+  }
+}
+const uploadedMedia = new UploadedMedia();
+export default uploadedMedia;
+export type { UploadedMediaParams };

src/__mocks__/mockedDb/wp_usermeta.ts

@@ -6,6 +6,8 @@ export const table = {
     await sqlite3.createTable(tableName, [
       "id INTEGER PRIMARY KEY",
       "user_id INTEGER NOT NULL",
+      "meta_key VARCHAR(255)",
+      "meta_value LONGTEXT",
     ]);
   },
   drop: async () => {
@@ -16,6 +18,8 @@ export const table = {
 type WpUsersMetaParams = {
   id?: number;
   user_id?: number;
+  meta_key?: string;
+  meta_value?: string;
 };
 const data: {
   [key: string]: (

src/features/db/__mocks__/index.ts

@@ -4,33 +4,34 @@ import mysql from "mysql";
 export const format = (query: string, data: (string | number)[]) =>
   mysql.format(query.replace(/"/g, "'"), data);
 
-export const query = (query: string): Promise<any> => {
-  return new Promise(async (resolve, reject) => {
-    try {
-      let data;
-      if (
-        query.includes("UPDATE") ||
-        query.includes("DELETE") ||
-        query.includes("INSERT")
-      ) {
-        data = await sqlite.run(query);
-        if (data.hasOwnProperty("lastInsertRowid")) {
-          data.insertId = data.lastInsertRowid;
-        }
-        if (data.hasOwnProperty("changes") && query.includes("UPDATE")) {
-          data.changedRows = data.changes;
-        }
-        if (data.hasOwnProperty("changes") && query.includes("DELETE")) {
-          data.affectedRows = data.changes;
-        }
-      } else {
-        data = await sqlite.all(query);
+export const query = async (query: string): Promise<any> => {
+  try {
+    let data;
+    if (
+      query.includes("UPDATE") ||
+      query.includes("DELETE") ||
+      query.includes("INSERT")
+    ) {
+      data = await sqlite.run(query);
+      if (data.hasOwnProperty("lastInsertRowid")) {
+        data.insertId = data.lastInsertRowid;
       }
-      return resolve(data);
-    } catch (error) {
-      return reject(error);
+      if (data.hasOwnProperty("changes") && query.includes("UPDATE")) {
+        data.changedRows = data.changes;
+      }
+      if (data.hasOwnProperty("changes") && query.includes("DELETE")) {
+        data.affectedRows = data.changes;
+      }
+    } else {
+      data = await sqlite.all(query);
     }
-  });
+    return data;
+  } catch (error) {
+    if ((error as { code: string }).code === "SQLITE_CONSTRAINT_UNIQUE") {
+      (error as { code: string }).code = "ER_DUP_ENTRY";
+    }
+    throw error;
+  }
 };
 
 export const insert = (table: string, data: any): Promise<any> => {

src/features/sqlite/index.ts

@@ -51,18 +51,20 @@ mockDb.all = (query: string): Promise<any> => {
     }
   });
 };
-mockDb.get = (query: string): Promise<any> => {
-  return new Promise(async (resolve, reject) => {
-    const data = await db.prepare(query).get();
-    resolve(data);
-  });
+mockDb.get = async (query: string): Promise<any> => {
+  try {
+    return await db.prepare(query).get();
+  } catch (e) {
+    throw e;
+  }
 };
 
-mockDb.run = (query: string): Promise<any> => {
-  return new Promise(async (resolve, reject) => {
-    const data = await db.prepare(query).run();
-    resolve(data);
-  });
+mockDb.run = async (query: string): Promise<any> => {
+  try {
+    return await db.prepare(query).run();
+  } catch (e) {
+    throw e;
+  }
 };
 
 mockDb.insert = (table: string, data: any): Promise<any> => {

src/routes/users/me/campaigns/campaignId/media/_post/index.spec.ts

@@ -4,6 +4,7 @@ import Candidature from "@src/__mocks__/mockedDb/cpHasCandidates";
 import { data as profileData } from "@src/__mocks__/mockedDb/profile";
 import WpOptions from "@src/__mocks__/mockedDb/wp_options";
 import { data as wpUserData } from "@src/__mocks__/mockedDb/wp_users";
+import UploadedMedia from "@src/__mocks__/mockedDb/uploadedMedia";
 import request from "supertest";
 import crypt from "./crypt";
 
@@ -31,6 +32,7 @@ describe("Route POST /users/me/campaign/{campaignId}/media", () => {
     await profileData.drop();
     await WpOptions.clear();
     await Candidature.clear();
+    await UploadedMedia.clear();
   });
   afterEach(async () => {
     jest.clearAllMocks();
@@ -121,6 +123,23 @@ describe("Route POST /users/me/campaign/{campaignId}/media", () => {
       )
     ).toBe(true);
   });
+  it("Should insert on DB uploaded files", async () => {
+    const response = await request(app)
+      .post("/users/me/campaigns/1/media")
+      .attach("media", mockFileBuffer, "void.png")
+      .set("Authorization", "Bearer tester");
+    expect(response.status).toBe(200);
+    const insertedMedia = await UploadedMedia.all();
+    expect(insertedMedia).not.toEqual(undefined);
+    expect(insertedMedia[0].url).toEqual(response.body.files[0].path);
+    console.log(insertedMedia[0].creation_date);
+    if (insertedMedia[0].creation_date)
+      expect(
+        insertedMedia[0].creation_date.startsWith(
+          new Date().toISOString().substring(0, 10)
+        )
+      ).toBe(true);
+  });
   it("Should crypt the filename on s3", async () => {
     const response = await request(app)
       .post("/users/me/campaigns/1/media")

src/routes/users/me/campaigns/campaignId/media/_post/index.ts

@@ -1,10 +1,10 @@
 import * as db from "@src/features/db";
-import postUserMedia from "@src/routes/media/_post";
 import { Context } from "openapi-backend";
 import busboyMapper from "@src/features/busboyMapper";
 import path from "path";
 import crypt from "./crypt";
 import upload from "@src/features/upload";
+import debugMessage from "@src/features/debugMessage";
 /** OPENAPI-ROUTE: post-users-me-campaigns-campaignId-media */
 export default async (
   c: Context,
@@ -74,20 +74,26 @@ export default async (
   > {
     let uploadedFiles = [];
     for (const media of files) {
+      const currentPath = (
+        await upload({
+          bucket: process.env.MEDIA_BUCKET || "",
+          key: getKey({
+            testerId: testerId,
+            filename: path.basename(media.name, path.extname(media.name)),
+            extension: path.extname(media.name),
+          }),
+          file: media,
+        })
+      ).toString();
+
       uploadedFiles.push({
         name: media.name,
-        path: (
-          await upload({
-            bucket: process.env.MEDIA_BUCKET || "",
-            key: getKey({
-              testerId: testerId,
-              filename: path.basename(media.name, path.extname(media.name)),
-              extension: path.extname(media.name),
-            }),
-            file: media,
-          })
-        ).toString(),
+        path: currentPath,
       });
+      await createUploadedFile(
+        currentPath,
+        new Date().toISOString().split(".")[0].replace("T", " ")
+      );
     }
     return uploadedFiles;
   }
@@ -106,4 +112,19 @@ export default async (
       `${filename}_${new Date().getTime()}`
     )}${extension}`;
   }
+
+  async function createUploadedFile(path: string, creationDate: string) {
+    try {
+      await db.query(
+        db.format(
+          `
+        INSERT INTO wp_appq_uploaded_media (url, creation_date)
+        VALUES (?, ?);`,
+          [path, creationDate]
+        )
+      );
+    } catch (e) {
+      debugMessage(e);
+    }
+  }
 };

src/routes/users/me/certifications/_post/index.spec.ts

@@ -0,0 +1,77 @@
+import { data as certificationData } from "@src/__mocks__/mockedDb/certificationList";
+import { data as testerCertificationData } from "@src/__mocks__/mockedDb/testerCertification";
+import { data as userMetaData } from "@src/__mocks__/mockedDb/wp_usermeta";
+import app from "@src/app";
+import request from "supertest";
+
+describe("Route POST single-certification", () => {
+  beforeEach(async () => {
+    return new Promise(async (resolve) => {
+      await certificationData.certification1();
+      await userMetaData.basicMeta();
+
+      resolve(null);
+    });
+  });
+  afterEach(async () => {
+    return new Promise(async (resolve) => {
+      await testerCertificationData.drop();
+      await certificationData.drop();
+      await userMetaData.drop();
+
+      resolve(null);
+    });
+  });
+
+  it("Should answer 403 if not logged in", async () => {
+    const response = await request(app).delete("/users/me/certifications/1");
+    expect(response.status).toBe(403);
+  });
+  it("Should return 201 and the resource if a certification is sent", async () => {
+    const response = await request(app)
+      .post("/users/me/certifications")
+      .send({ certification_id: 1, achievement_date: "2020-01-01" })
+      .set("authorization", "Bearer tester");
+    expect(response.status).toBe(201);
+    expect(response.body).toMatchObject({
+      id: 1,
+      name: "Best Tryber Ever",
+      area: "Testing 360",
+      institute: "Tryber",
+      achievement_date: "2020-01-01",
+    });
+  });
+  //new user doesn't have any certification and doesn't have emptyCerts meta
+  // when add first certification, it should add emptyCerts meta to usermeta as false
+  // if user remove all certifications, remain emptyCerts meta as false
+  it("Should return an error if sending an inexistent certification", async () => {
+    const response = await request(app)
+      .post("/users/me/certifications")
+      .send({ certification_id: 69, achievement_date: "2020-01-01" })
+      .set("authorization", "Bearer tester");
+
+    expect(response.status).toBe(400);
+    expect(response.body).toMatchObject({
+      id: 0,
+      element: "certifications",
+      message: "Can't find certification with id 69",
+    });
+  });
+  it("Should return an error if send a certification that the user already owns", async () => {
+    const response = await request(app)
+      .post("/users/me/certifications")
+      .send({ certification_id: 1, achievement_date: "2020-01-01" })
+      .set("authorization", "Bearer tester");
+
+    const responseTwinCertification = await request(app)
+      .post("/users/me/certifications")
+      .send({ certification_id: 1, achievement_date: "2020-01-01" })
+      .set("authorization", "Bearer tester");
+
+    expect(responseTwinCertification.status).toBe(400);
+    expect(responseTwinCertification.body).toMatchObject({
+      message:
+        "Failed. Duplication entry. Certification already assigned to the tester.",
+    });
+  });
+});