add additional/missing tests

src/routes/getDaysSavedFormatted.ts

@@ -7,7 +7,11 @@ export async function getDaysSavedFormatted(req: Request, res: Response): Promis
     if (row !== undefined) {
         //send this result
         return res.send({
-            daysSaved: row.daysSaved.toFixed(2),
+            daysSaved: row.daysSaved?.toFixed(2) ?? "0",
+        });
+    } else {
+        return res.send({
+            daysSaved: 0
         });
     }
 }

test/cases/addUserAsVIP.ts

@@ -0,0 +1,92 @@
+import { getHash } from "../../src/utils/getHash";
+import { HashedUserID } from "../../src/types/user.model";
+import { client } from "../utils/httpClient";
+import { db } from "../../src/databases/databases";
+import assert from "assert";
+
+// helpers
+const checkUserVIP = (publicID: string) => db.prepare("get", `SELECT "userID" FROM "vipUsers" WHERE "userID" = ?`, [publicID]);
+
+const adminPrivateUserID = "testUserId";
+const permVIP1 = "addVIP_permaVIPOne";
+const publicPermVIP1 = getHash(permVIP1) as HashedUserID;
+
+const endpoint = "/api/addUserAsVIP";
+const addUserAsVIP = (userID: string, enabled: boolean, adminUserID = adminPrivateUserID) => client({
+    method: "POST",
+    url: endpoint,
+    params: {
+        userID,
+        adminUserID,
+        enabled: String(enabled)
+    }
+});
+
+describe("addVIP test", function() {
+    it("User should not already be VIP", (done) => {
+        checkUserVIP(publicPermVIP1)
+            .then(result => {
+                assert.ok(!result);
+                done();
+            })
+            .catch(err => done(err));
+    });
+    it("Should be able to add user as VIP", (done) => {
+        addUserAsVIP(publicPermVIP1, true)
+            .then(async res => {
+                assert.strictEqual(res.status, 200);
+                const row = await checkUserVIP(publicPermVIP1);
+                assert.ok(row);
+                done();
+            })
+            .catch(err => done(err));
+    });
+    it("Should return 403 with invalid adminID", (done) => {
+        addUserAsVIP(publicPermVIP1, true, "Invalid_Admin_User_ID")
+            .then(res => {
+                assert.strictEqual(res.status, 403);
+                done();
+            })
+            .catch(err => done(err));
+    });
+    it("Should return 400 with missing adminID", (done) => {
+        client({
+            method: "POST",
+            url: endpoint,
+            params: {
+                userID: publicPermVIP1,
+                enabled: String(true)
+            }
+        })
+            .then(res => {
+                assert.strictEqual(res.status, 400);
+                done();
+            })
+            .catch(err => done(err));
+    });
+    it("Should return 400 with missing userID", (done) => {
+        client({
+            method: "POST",
+            url: endpoint,
+            params: {
+                enabled: String(true),
+                adminUserID: adminPrivateUserID
+            }
+        })
+            .then(res => {
+                assert.strictEqual(res.status, 400);
+                done();
+            })
+            .catch(err => done(err));
+    });
+    it("Should be able to remove VIP", (done) => {
+        addUserAsVIP(publicPermVIP1, false)
+            .then(async res => {
+                assert.strictEqual(res.status, 200);
+                const row = await checkUserVIP(publicPermVIP1);
+                assert.ok(!row);
+                done();
+            })
+            .catch(err => done(err));
+    });
+});

test/cases/getDaysSavedFormatted.ts

@@ -0,0 +1,11 @@
+import assert from "assert";
+import { client } from "../utils/httpClient";
+
+const endpoint = "/api/getDaysSavedFormatted";
+
+describe("getDaysSavedFormatted", () => {
+    it("can get days saved", async () => {
+        const result = await client({ url: endpoint });
+        assert.ok(result.data.daysSaved >= 0);
+    });
+});

test/cases/getSavedTimeForUser.ts

@@ -2,22 +2,31 @@ import { db } from "../../src/databases/databases";
 import { getHash } from "../../src/utils/getHash";
 import { deepStrictEqual } from "assert";
 import { client } from "../utils/httpClient";
+import assert from "assert";
+
+// helpers
 const endpoint = "/api/getSavedTimeForUser";
+const getSavedTimeForUser = (userID: string) => client({
+    url: endpoint,
+    params: { userID }
+});
 
 describe("getSavedTimeForUser", () => {
-    const user1 = "getSavedTimeForUserUser";
+    const user1 = "getSavedTimeForUser1";
+    const user2 = "getSavedTimeforUser2";
+    const [ start, end, views ] = [1, 11, 50];
+
     before(async () => {
         const startOfQuery = 'INSERT INTO "sponsorTimes" ("videoID", "startTime", "endTime", "votes", "UUID", "userID", "timeSubmitted", "views", "shadowHidden") VALUES';
         await db.prepare("run", `${startOfQuery}(?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-            ["getSavedTimeForUser", 1, 11, 2, "gstfu0", getHash(user1), 0, 50, 0]);
+            ["getSavedTimeForUser", start, end, 2, "getSavedTimeUUID0", getHash(user1), 0, views, 0]);
         return;
     });
-
-    it("Should be able to get a 200", (done) => {
-        client.get(endpoint, { params: { userID: user1 } })
+    it("Should be able to get a saved time", (done) => {
+        getSavedTimeForUser(user1)
             .then(res => {
                 // (end-start)*minute * views
-                const savedMinutes = ((11-1)/60) * 50;
+                const savedMinutes = ((end-start)/60) * views;
                 const expected = {
                     timeSaved: savedMinutes
                 };
@@ -26,4 +35,20 @@ describe("getSavedTimeForUser", () => {
             })
             .catch((err) => done(err));
     });
+    it("Should return 404 if no submissions", (done) => {
+        getSavedTimeForUser(user2)
+            .then(res => {
+                assert.strictEqual(res.status, 404);
+                done();
+            })
+            .catch((err) => done(err));
+    });
+    it("Should return 400 if no userID", (done) => {
+        client({ url: endpoint })
+            .then(res => {
+                assert.strictEqual(res.status, 400);
+                done();
+            })
+            .catch((err) => done(err));
+    });
 });

test/cases/getTotalStats.ts

@@ -0,0 +1,17 @@
+import assert from "assert";
+import { client } from "../utils/httpClient";
+
+const endpoint = "/api/getTotalStats";
+
+describe("getTotalStats", () => {
+    it("Can get total stats", async () => {
+        const result = await client({ url: endpoint });
+        const data = result.data;
+        assert.ok(data.userCount >= 0);
+        assert.ok(data.activeUsers >= 0);
+        assert.ok(data.apiUsers >= 0);
+        assert.ok(data.viewCount >= 0);
+        assert.ok(data.totalSubmissions >= 0);
+        assert.ok(data.minutesSaved >= 0);
+    });
+});

test/cases/getUsername.ts

@@ -0,0 +1,53 @@
+import { getHash } from "../../src/utils/getHash";
+import { client } from "../utils/httpClient";
+import assert from "assert";
+
+// helpers
+const getUsername = (userID: string) => client({
+    url: "/api/getUsername",
+    params: { userID }
+});
+
+const postSetUserName = (userID: string, username: string) => client({
+    method: "POST",
+    url: "/api/setUsername",
+    params: {
+        userID,
+        username,
+    }
+});
+
+const userOnePrivate = "getUsername_0";
+const userOnePublic = getHash(userOnePrivate);
+const userOneUsername = "getUsername_username";
+
+describe("getUsername test", function() {
+    it("Should get back publicUserID if not set", (done) => {
+        getUsername(userOnePrivate)
+            .then(result => {
+                assert.strictEqual(result.data.userName, userOnePublic);
+                done();
+            })
+            .catch(err => done(err));
+    });
+    it("Should be able to get username after setting", (done) => {
+        postSetUserName(userOnePrivate, userOneUsername)
+            .then(async () => {
+                const result = await getUsername(userOnePrivate);
+                const actual = result.data.userName;
+                assert.strictEqual(actual, userOneUsername);
+                done();
+            })
+            .catch(err => done(err));
+    });
+    it("Should return 400 if no userID provided", (done) => {
+        client({
+            url: "/api/getUsername"
+        })
+            .then(res => {
+                assert.strictEqual(res.status, 400);
+                done();
+            })
+            .catch(err => done(err));
+    });
+});

test/cases/getViewsForUser.ts

@@ -0,0 +1,62 @@
+import { getHash } from "../../src/utils/getHash";
+import { db } from "../../src/databases/databases";
+import { client } from "../utils/httpClient";
+import assert from "assert";
+
+// helpers
+const endpoint = "/api/getViewsForUser";
+const getViewsForUser = (userID: string) => client({
+    url: endpoint,
+    params: { userID }
+});
+
+const getViewUserOne = "getViewUser1";
+const userOneViewsFirst = 30;
+const userOneViewsSecond = 0;
+
+const getViewUserTwo = "getViewUser2";
+const userTwoViews = 0;
+
+const getViewUserThree = "getViewUser3";
+
+
+describe("getViewsForUser", function() {
+    before(() => {
+        const insertSponsorTimeQuery = 'INSERT INTO "sponsorTimes" ("videoID", "startTime", "endTime", "votes", "UUID", "userID", "timeSubmitted", views, category, "actionType", "videoDuration", "shadowHidden", "hashedVideoID") VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)';
+        db.prepare("run", insertSponsorTimeQuery, ["getViewUserVideo", 0, 1, 0, "getViewUserVideo0", getHash(getViewUserOne), 0, userOneViewsFirst, "sponsor", "skip", 0, 0, "getViewUserVideo"]);
+        db.prepare("run", insertSponsorTimeQuery, ["getViewUserVideo", 0, 1, 0, "getViewUserVideo1", getHash(getViewUserOne), 0, userOneViewsSecond, "sponsor", "skip", 0, 0, "getViewUserVideo"]);
+        db.prepare("run", insertSponsorTimeQuery, ["getViewUserVideo", 0, 1, 0, "getViewUserVideo2", getHash(getViewUserTwo), 0, userTwoViews, "sponsor", "skip", 0, 0, "getViewUserVideo"]);
+    });
+    it("Should get back views for user one", (done) => {
+        getViewsForUser(getViewUserOne)
+            .then(result => {
+                assert.strictEqual(result.data.viewCount, userOneViewsFirst + userOneViewsSecond);
+                done();
+            })
+            .catch(err => done(err));
+    });
+    it("Should get back views for user two", (done) => {
+        getViewsForUser(getViewUserTwo)
+            .then(result => {
+                assert.strictEqual(result.data.viewCount, userTwoViews);
+                done();
+            })
+            .catch(err => done(err));
+    });
+    it("Should get 404 if no submissions", (done) => {
+        getViewsForUser(getViewUserThree)
+            .then(result => {
+                assert.strictEqual(result.status, 404);
+                done();
+            })
+            .catch(err => done(err));
+    });
+    it("Should return 400 if no userID provided", (done) => {
+        client({ url: endpoint })
+            .then(res => {
+                assert.strictEqual(res.status, 400);
+                done();
+            })
+            .catch(err => done(err));
+    });
+});