getChapterNames

- remove identifier from segmentGen
- add multiGenRandomValue
- add videoInfo query

test/cases/getChapterNames.ts

@@ -3,59 +3,43 @@ import { db } from "../../src/databases/databases";
 import { Postgres } from "../../src/databases/Postgres";
 import { client } from "../utils/httpClient";
 import { partialDeepEquals } from "../utils/partialDeepEquals";
+import { insertChapter } from "../utils/segmentQueryGen";
+import { genRandomValue } from "../utils/getRandom";
+import { insertVideoInfo } from "../utils/queryGen";
 
-// Only works with Postgres
+describe("getChapterNames", function () {
-if (db instanceof Postgres) {
+    const endpoint = "/api/chapterNames";
 
-    describe("getChapterNames", function () {
+    const chapterNamesVid1 = genRandomValue("video", "getChapterNames");
-        const endpoint = "/api/chapterNames";
+    const chapterChannelID = genRandomValue("channel", "getChapterNames");
+    const chapterNames = [
+        "Weird name",
+        "A different one",
+        "Something else",
+    ];
 
-        const chapterNamesVid1 = "chapterNamesVid";
+    const nameSearch = (query: string, expected: string): Promise<void> => {
-        const chapterChannelID = "chapterChannelID";
+        const expectedData = [{
+            description: expected
+        }];
+        return client.get(`${endpoint}?description=${query}&channelID=${chapterChannelID}`)
+            .then(res => {
+                assert.strictEqual(res.status, 200);
+                assert.strictEqual(res.data.length, 1);
+                assert.ok(partialDeepEquals(res.data, expectedData));
+            });
+    };
 
-        before(async () => {
+    before(async function() {
-            const query = 'INSERT INTO "sponsorTimes" ("videoID", "startTime", "endTime", "votes", "locked", "UUID", "userID", "timeSubmitted", "views", "category", "actionType", "service", "videoDuration", "hidden", "shadowHidden", "description") VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)';
+        if (!(db instanceof Postgres)) this.skip(); // only works with Postgres
-            await db.prepare("run", query, [chapterNamesVid1, 60, 80, 2, 0, "chapterNamesVid-1", "testman", 0, 50, "chapter", "chapter", "YouTube", 0, 0, 0, "Weird name"]);
+        await insertChapter(db, chapterNames[0], { videoID: chapterNamesVid1, startTime: 60, endTime: 80 });
-            await db.prepare("run", query, [chapterNamesVid1, 70, 75, 2, 0, "chapterNamesVid-2", "testman", 0, 50, "chapter", "chapter", "YouTube", 0, 0, 0, "A different one"]);
+        await insertChapter(db, chapterNames[1], { videoID: chapterNamesVid1, startTime: 70, endTime: 75 });
-            await db.prepare("run", query, [chapterNamesVid1, 71, 76, 2, 0, "chapterNamesVid-3", "testman", 0, 50, "chapter", "chapter", "YouTube", 0, 0, 0, "Something else"]);
+        await insertChapter(db, chapterNames[2], { videoID: chapterNamesVid1, startTime: 71, endTime: 76 });
 
-            await db.prepare("run", `INSERT INTO "videoInfo" ("videoID", "channelID", "title", "published") 
+        await insertVideoInfo(db, chapterNamesVid1, chapterChannelID);
-                SELECT ?, ?, ?, ?`, [
-                chapterNamesVid1, chapterChannelID, "", 0
-            ]);
-        });
-
-        it("Search for 'weird'", async () => {
-            const result = await client.get(`${endpoint}?description=weird&channelID=${chapterChannelID}`);
-            const expected = [{
-                description: "Weird name",
-            }];
-
-            assert.strictEqual(result.status, 200);
-            assert.strictEqual(result.data.length, 3);
-            assert.ok(partialDeepEquals(result.data, expected));
-        });
-
-        it("Search for 'different'", async () => {
-            const result = await client.get(`${endpoint}?description=different&channelID=${chapterChannelID}`);
-            const expected = [{
-                description: "A different one",
-            }];
-
-            assert.strictEqual(result.status, 200);
-            assert.strictEqual(result.data.length, 3);
-            assert.ok(partialDeepEquals(result.data, expected));
-        });
-
-        it("Search for 'something'", async () => {
-            const result = await client.get(`${endpoint}?description=something&channelID=${chapterChannelID}`);
-            const expected = [{
-                description: "Something else",
-            }];
-
-            assert.strictEqual(result.status, 200);
-            assert.strictEqual(result.data.length, 3);
-            assert.ok(partialDeepEquals(result.data, expected));
-        });
     });
-}
+
+    it("Search for 'weird'", () => nameSearch("weird", chapterNames[0]));
+    it("Search for 'different'", () => nameSearch("different", chapterNames[1]));
+    it("Search for 'something'", () => nameSearch("something", chapterNames[2]));
+});

test/cases/postClearCache.ts

@@ -16,7 +16,7 @@ const users = genUsers("postClearCache", cases);
 describe("postClearCache", () => {
     before(async () => {
         await insertVip(db, users["vip"].pubID);
-        await insertSegment(db, "clearSegments", "clear-test", { videoID: "clear-test" });
+        await insertSegment(db, { videoID: "clear-test" });
     });
 
     it("Should be able to clear cache for existing video", () =>

test/utils/getRandom.ts

@@ -1,5 +1,10 @@
 import crypto from "crypto";
 
-export const genRandom = (bytes=8) => crypto.pseudoRandomBytes(bytes).toString("hex");
+export const genRandom = (bytes=8): string => crypto.pseudoRandomBytes(bytes).toString("hex");
 
-export const genRandomValue = (prefix: string, identifier: string, bytes=8) => `${prefix}-${identifier}-${genRandom(bytes)}`;
+export const genRandomValue = (prefix: string, identifier: string, bytes=8): string => `${prefix}-${identifier}-${genRandom(bytes)}`;
+export const multiGenRandomValue = (prefix: string, identifier: string, count: number, bytes=8): string[] => {
+    const arr: string[] = [];
+    for (let i = 0; i < count; i++) arr.push(genRandomValue(prefix, identifier, bytes));
+    return arr;
+};

test/utils/queryGen.ts

@@ -39,3 +39,9 @@ export const insertUsernameBulk = async (db: IDatabase, users: usernameUserArray
     for (const user of Object.values(users))
         await insertUsername(db, user.pubID, user.username, false);
 };
+
+// videoInfo
+export const insertVideoInfo = async (db: IDatabase, videoID: string, channelID: string, title = "", published = 0) => {
+    const query = 'INSERT INTO "videoInfo" ("videoID", "channelID", "title", "published") VALUES(?, ?, ?, ?)';
+    await db.prepare("run", query, [videoID, channelID, title, published]);
+};

test/utils/segmentQueryGen.ts

@@ -1,7 +1,7 @@
 import { IDatabase } from "../../src/databases/IDatabase";
 import { Service, VideoIDHash, VideoID } from "../../src/types/segments.model";
 import { HashedUserID, UserID } from "../../src/types/user.model";
-import { genRandomValue } from "./getRandom";
+import { genRandom, genRandomValue } from "./getRandom";
 import { getHash } from "../../src/utils/getHash";
 
 type insertSegmentParams = {
@@ -43,12 +43,11 @@ const defaultSegmentParams: insertSegmentParams = {
     description: ""
 };
 
-// sponsorTimes
+export const insertSegment = async(db: IDatabase, params: insertSegmentParams = {}) => {
-export const insertSegment = async(db: IDatabase, fnname: string, testcase: string, params: insertSegmentParams = {}) => {
     const query = 'INSERT INTO "sponsorTimes" ("videoID", "startTime", "endTime", "votes", "locked", "UUID", "userID", "timeSubmitted", "views", "category", "actionType", "service", "videoDuration", "hidden", "shadowHidden", "hashedVideoID", "description") VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)';
     // corrections for parameters
-    const identifier = `${fnname}-${testcase}`;
     const correctedParams = { ...defaultSegmentParams, ...params };
+    const identifier = genRandom(7); // 7 to fill out videoID
     // generate defaults
     const videoID = (params.videoID || `vid-${identifier}`) as VideoID;
     const userID = (params.userID || `user-${identifier}`) as UserID;
@@ -61,4 +60,8 @@ export const insertSegment = async(db: IDatabase, fnname: string, testcase: stri
     correctedParams.hidden = Number(correctedParams.hidden);
     correctedParams.shadowHidden = Number(correctedParams.shadowHidden);
     await db.prepare("run", query, Object.values(correctedParams));
+};
+export const insertChapter = async(db: IDatabase, description: string, params: insertSegmentParams = {}) => {
+    const overrides = { category: "chapter", actionType: "chapter", description, ...params };
+    await insertSegment(db, overrides);
 };