Cleanup profile & add specification

Author: Timothy-Gonzalez

.eslintrc.cjs

@@ -29,7 +29,7 @@ module.exports = {
         curly: ["error", "all"],
         "consistent-return": "error",
         "no-lonely-if": "error",
-        "no-magic-numbers": ["error", { ignoreClassFieldInitialValues: true, ignore: [0, 1] }],
+        "no-magic-numbers": ["error", { ignoreClassFieldInitialValues: true, ignore: [0, 1, 2] }],
         "no-multi-assign": "error",
         "no-nested-ternary": "error",
         "no-var": "error",

src/common/config.ts

@@ -27,7 +27,7 @@ export enum RegistrationTemplates {
     RSVP_REMINDER_1_DAY = "2024_rsvp-reminder",
 }
 
-export enum Avatars {
+export enum Avatar {
     BUNNY = "bunny",
     SQUIRREL = "squirrel",
     GOBLIN = "goblin",

src/common/testTools.ts

@@ -1,6 +1,7 @@
 import request from "supertest";
 
 import { Provider, Role } from "../services/auth/auth-schemas";
+import { Avatar } from "./config";
 
 // The tester is the user that will be making requests
 // We provide this object so you can do proper testing based on JWT auth
@@ -9,7 +10,8 @@ export const TESTER = {
     id: "bob-the-tester101010101011",
     email: "bob-the-tester@hackillinois.org",
     name: "Bob Tester",
-    avatarUrl: "https://hackillinois.org/mushroom.png",
+    avatarId: Avatar.MUSHROOM,
+    avatarUrl: "https://raw.githubusercontent.com/HackIllinois/adonix-metadata/main/avatars/mushroom.png",
     discordTag: "hackillinoistest",
     userName: "bobster_the_mobster",
 };

src/database/attendee-db.ts

@@ -2,7 +2,7 @@ import mongoose, { Model } from "mongoose";
 import { getModelForClass } from "@typegoose/typegoose";
 
 import { AuthInfo } from "../services/auth/auth-schemas";
-import { AttendeeProfile } from "./attendee-db";
+import { AttendeeProfile } from "../services/profile/profile-schemas";
 import { AdmissionDecision } from "../services/admission/admission-schemas";
 import { MentorOfficeHours } from "./mentor-db";
 import { Event, EventAttendance, EventFollowers } from "../services/event/event-schemas";

src/database/models.ts

@@ -177,9 +177,6 @@ admissionRouter.put(
     async (req, res) => {
         const updateEntries = req.body;
 
-        console.log("updatedEntries");
-        console.log(updateEntries);
-
         // collect emails whose status changed from TBD -> NON-TBD
         const recipients: string[] = [];
         for (const entry of updateEntries) {

src/services/admission/admission-router.ts

@@ -112,8 +112,6 @@ eventsRouter.get(
         const { id: eventId } = req.params;
         const roles = tryGetAuthenticatedUser(req)?.roles || [];
 
-        console.log(eventId, roles, restrictEventsByRoles(roles));
-
         const event = await Models.Event.findOne({ eventId, ...restrictEventsByRoles(roles) });
 
         if (!event) {

src/services/event/event-router.ts

@@ -1,4 +1,4 @@
-import { AttendeeProfile } from "../../database/attendee-db";
+import { AttendeeProfile } from "./profile-schemas";
 
 export function isValidProfileFormat(profile: AttendeeProfile): boolean {
     if (!profile) {

src/services/profile/profile-formats.ts

@@ -1,30 +1,7 @@
-import { AttendeeProfile } from "../../database/attendee-db";
-import { LeaderboardEntry } from "./profile-models";
+import { AttendeeProfile } from "./profile-schemas";
 import { UpdateQuery } from "mongoose";
 import Models from "../../database/models";
 
-/**
- * Remove non-necessary fields from a leaderboardentry item
- * @param initial Initial entry with extra items
- * @returns New LeaderboardEntry, but this time with only the needed fields
- */
-export function castLeaderboardEntries(initial: AttendeeProfile): LeaderboardEntry {
-    const final: LeaderboardEntry = {
-        points: initial.points,
-        displayName: initial.displayName,
-    };
-    return final;
-}
-
-/**
- * Check if the limit is valid or not
- * @param limit Initial value to check
- * @returns True if limit is non-negative, else false
- */
-export function isValidLimit(limit: number): boolean {
-    return limit > 0;
-}
-
 export async function updatePointsAndCoins(userId: string, amount: number): Promise<AttendeeProfile | null> {
     await updateCoins(userId, amount);
 

src/services/profile/profile-lib.ts

@@ -1,9 +1,10 @@
 import { beforeEach, describe, expect, it } from "@jest/globals";
 import { StatusCode } from "status-code-enum";
 import Config from "../../common/config";
-import { AttendeeProfile } from "../../database/attendee-db";
+import { AttendeeProfile, AttendeeProfileCreateRequest } from "./profile-schemas";
 import Models from "../../database/models";
-import { TESTER, delAsUser, getAsAdmin, getAsUser, postAsAttendee, postAsStaff, postAsUser } from "../../common/testTools";
+import { TESTER, getAsAdmin, getAsAttendee, getAsUser, postAsAttendee, postAsStaff, postAsUser } from "../../common/testTools";
+import { Degree, Gender, HackInterest, HackOutreach, Race, RegistrationApplication } from "../registration/registration-schemas";
 
 const TESTER_USER = {
     userId: TESTER.id,
@@ -35,112 +36,137 @@ const TESTER_USER_3 = {
     foodWave: 2,
 } satisfies AttendeeProfile;
 
-const profile: AttendeeProfile = {
-    userId: TESTER.id,
+const CREATE_REQUEST = {
+    avatarId: TESTER.avatarId,
     displayName: TESTER.name,
-    avatarUrl: TESTER.avatarUrl,
     discordTag: TESTER.discordTag,
+} satisfies AttendeeProfileCreateRequest;
+
+const PROFILE = {
+    userId: TESTER.id,
+    displayName: CREATE_REQUEST.displayName,
+    avatarUrl: TESTER.avatarUrl,
+    discordTag: CREATE_REQUEST.discordTag,
     points: 0,
     coins: 0,
     foodWave: 1,
-};
+} satisfies AttendeeProfile;
+
+const REGISTRATION = {
+    userId: TESTER.id,
+    hasSubmitted: true,
+    isProApplicant: false,
+    preferredName: TESTER.name,
+    legalName: TESTER.name,
+    emailAddress: TESTER.email,
+    university: "ap",
+    hackEssay1: "ap",
+    hackEssay2: "ap",
+    optionalEssay: "ap",
+    location: "ap",
+    gender: Gender.OTHER,
+    degree: Degree.BACHELORS,
+    major: "CS",
+    gradYear: 0,
+    requestedTravelReimbursement: false,
+    dietaryRestrictions: ["some restriction"],
+    race: [Race.NO_ANSWER],
+    hackInterest: [HackInterest.TECHNICAL_WORKSHOPS],
+    hackOutreach: [HackOutreach.INSTAGRAM],
+} satisfies RegistrationApplication;
 
 beforeEach(async () => {
     await Models.AttendeeProfile.create(TESTER_USER);
     await Models.AttendeeProfile.create(TESTER_USER_2);
     await Models.AttendeeProfile.create(TESTER_USER_3);
+    await Models.RegistrationApplication.create(REGISTRATION);
 });
 
 describe("POST /profile", () => {
     it("works for an attendee", async () => {
         await Models.AttendeeProfile.deleteOne({ userId: TESTER_USER.userId });
-        const response = await postAsAttendee("/profile/").send(profile).expect(StatusCode.SuccessOK);
+        const response = await postAsAttendee("/profile/").send(CREATE_REQUEST).expect(StatusCode.SuccessOK);
 
         expect(JSON.parse(response.text)).toHaveProperty("displayName", TESTER.name);
+
+        const stored = await Models.AttendeeProfile.findOne({ userId: TESTER_USER.userId });
+        expect(stored?.toObject()).toMatchObject(PROFILE);
     });
 
     it("fails when a profile is already created", async () => {
         await Models.AttendeeProfile.deleteOne({ userId: TESTER_USER.userId });
-        const response = await postAsUser("/profile/").send(profile).expect(StatusCode.SuccessOK);
+        const response = await postAsAttendee("/profile/").send(CREATE_REQUEST).expect(StatusCode.SuccessOK);
 
-        expect(JSON.parse(response.text)).toHaveProperty("displayName", TESTER.name);
+        expect(JSON.parse(response.text)).toMatchObject(PROFILE);
+
+        const stored = await Models.AttendeeProfile.findOne({ userId: TESTER_USER.userId });
+        expect(stored?.toObject()).toMatchObject(PROFILE);
 
         // to verify they can't double create
-        const response2 = await postAsUser("/profile/").send(profile).expect(StatusCode.ClientErrorBadRequest);
-        expect(JSON.parse(response2.text)).toHaveProperty("error", "UserAlreadyExists");
+        const response2 = await postAsAttendee("/profile/").send(CREATE_REQUEST).expect(StatusCode.ClientErrorBadRequest);
+        expect(JSON.parse(response2.text)).toHaveProperty("error", "AlreadyExists");
     });
 
     it("fails when invalid data is provided", async () => {
-        const response = await postAsUser("/profile/")
+        const response = await postAsAttendee("/profile/")
             .send({
                 displayName: 123,
                 avatarId: 1,
                 discordTag: "test",
             })
             .expect(StatusCode.ClientErrorBadRequest);
 
-        expect(JSON.parse(response.text)).toHaveProperty("error", "InvalidParams");
+        expect(JSON.parse(response.text)).toHaveProperty("error", "BadRequest");
     });
 });
 
 describe("GET /profile", () => {
     it("fails to get a profile that doesn't exist", async () => {
         await Models.AttendeeProfile.deleteOne({ userId: TESTER_USER.userId });
 
-        const response = await getAsUser("/profile/").expect(StatusCode.ClientErrorNotFound);
+        const response = await getAsAttendee("/profile/").expect(StatusCode.ClientErrorNotFound);
 
-        expect(JSON.parse(response.text)).toHaveProperty("error", "UserNotFound");
+        expect(JSON.parse(response.text)).toHaveProperty("error", "NotFound");
     });
 
     it("gets a profile that exists", async () => {
-        const response = await getAsUser("/profile/").expect(StatusCode.SuccessOK);
-        expect(JSON.parse(response.text)).toHaveProperty("displayName", TESTER.name);
+        const response = await getAsAttendee("/profile/").expect(StatusCode.SuccessOK);
+        expect(JSON.parse(response.text)).toMatchObject(PROFILE);
     });
 });
 
-describe("GET /profile/userid/:USERID", () => {
-    it("fails to get a profile as a user", async () => {
-        const response = await getAsUser("/profile/userid/" + TESTER.id).expect(StatusCode.ClientErrorForbidden);
+describe("GET /profile/:id/", () => {
+    it("fails to get a profile as a attendee", async () => {
+        const response = await getAsAttendee(`/profile/${TESTER.id}`).expect(StatusCode.ClientErrorForbidden);
 
         expect(JSON.parse(response.text)).toHaveProperty("error", "Forbidden");
     });
 
     it("gets a profile as an admin", async () => {
-        const response = await getAsAdmin("/profile/userid/" + TESTER.id).expect(StatusCode.SuccessOK);
+        const response = await getAsAdmin(`/profile/${TESTER.id}`).expect(StatusCode.SuccessOK);
 
         expect(JSON.parse(response.text)).toHaveProperty("displayName", TESTER.name);
     });
 
     it("gets a user that doesnt exist", async () => {
-        const response = await getAsAdmin("/profile/userid/doesnotexist").expect(StatusCode.ClientErrorNotFound);
-
-        expect(JSON.parse(response.text)).toHaveProperty("error", "UserNotFound");
-    });
-});
-
-describe("DELETE /profile/", () => {
-    it("fails to delete a profile that doesn't exist", async () => {
-        await Models.AttendeeProfile.deleteOne({ userId: TESTER_USER.userId });
-        const response = await delAsUser("/profile").expect(StatusCode.ClientErrorNotFound);
-        expect(JSON.parse(response.text)).toHaveProperty("error", "AttendeeNotFound");
-    });
+        const response = await getAsAdmin("/profile/doesnotexist").expect(StatusCode.ClientErrorNotFound);
 
-    it("deletes a profile", async () => {
-        const response = await delAsUser("/profile").expect(StatusCode.SuccessOK);
-        expect(JSON.parse(response.text)).toHaveProperty("success", true);
+        expect(JSON.parse(response.text)).toHaveProperty("error", "NotFound");
     });
 });
 
 describe("GET /profile/leaderboard", () => {
     it("gets 3 entries when no limit is set", async () => {
-        await getAsUser("/profile/leaderboard").expect(StatusCode.SuccessOK);
+        const response = await getAsUser("/profile/leaderboard").expect(StatusCode.SuccessOK);
+        const parsed = JSON.parse(response.text);
+        expect(parsed.profiles.length).toBe(3);
     });
 
     it("gets with a limit of 2", async () => {
         const response = await getAsUser("/profile/leaderboard?limit=2").expect(StatusCode.SuccessOK);
 
-        const responseArray = JSON.parse(response.text);
-        expect(responseArray.profiles.length).toBeLessThan(3);
+        const parsed = JSON.parse(response.text);
+        expect(parsed.profiles.length).toBe(2);
     });
 
     it("only gets the max limit when no limit is set", async () => {
@@ -159,13 +185,13 @@ describe("GET /profile/leaderboard", () => {
         const response = await getAsUser("/profile/leaderboard").expect(StatusCode.SuccessOK);
         const responseArray = JSON.parse(response.text);
 
-        expect(responseArray.profiles.length).toBeLessThan(Config.LEADERBOARD_QUERY_LIMIT + 1);
+        expect(responseArray.profiles.length).toBe(Config.LEADERBOARD_QUERY_LIMIT);
     });
 
     it("fails when an invalid limit is set", async () => {
         const response = await getAsUser("/profile/leaderboard?limit=0").expect(StatusCode.ClientErrorBadRequest);
 
-        expect(JSON.parse(response.text)).toHaveProperty("error", "InvalidLimit");
+        expect(JSON.parse(response.text)).toHaveProperty("error", "BadRequest");
     });
 });
 
@@ -192,14 +218,14 @@ describe("GET /profile/addpoints", () => {
         expect(JSON.parse(response.text)).toHaveProperty("error", "Forbidden");
     });
 
-    it("returns UserNotFound for nonexistent users", async () => {
+    it("returns NotFound for nonexistent users", async () => {
         const response = await postAsStaff("/profile/addpoints")
             .send({
                 userId: "idontexists",
                 points: 10,
             })
-            .expect(StatusCode.ClientErrorBadRequest);
+            .expect(StatusCode.ClientErrorNotFound);
 
-        expect(JSON.parse(response.text)).toHaveProperty("error", "UserNotFound");
+        expect(JSON.parse(response.text)).toHaveProperty("error", "NotFound");
     });
 });