Skip to content

Commit ecbf809

Browse files
mchangrhmchangrh
committed
postPurgeAllSegments, setUsername
1 parent 5714f51 commit ecbf809

File tree

2 files changed

+96
-102
lines changed

2 files changed

+96
-102
lines changed

‎test/cases/postPurgeAllSegments.ts‎

Lines changed: 21 additions & 33 deletions
Original file line numberDiff line numberDiff line change
@@ -1,52 +1,40 @@
11
import { db } from "../../src/databases/databases";
2-
import { getHash } from "../../src/utils/getHash";
32
import { IDatabase } from "../../src/databases/IDatabase";
43
import assert from "assert";
54
import { client } from "../utils/httpClient";
65

7-
async function dbSponsorTimesAdd(db: IDatabase, videoID: string, startTime: number, endTime: number, UUID: string, category: string) {
8-
const votes = 0,
9-
userID = 0,
10-
timeSubmitted = 0,
11-
views = 0,
12-
shadowHidden = 0,
13-
hidden = 0,
14-
hashedVideoID = `hash_${UUID}`;
15-
await db.prepare("run", `INSERT INTO
16-
"sponsorTimes" ("videoID", "startTime", "endTime", "votes", "UUID",
17-
"userID", "timeSubmitted", "views", "category", "shadowHidden", "hashedVideoID", "hidden")
18-
VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
19-
[videoID, startTime, endTime, votes, UUID, userID, timeSubmitted, views, category, shadowHidden, hashedVideoID, hidden]);
20-
}
6+
import { insertSegment } from "../utils/segmentQueryGen";
7+
import { genAnonUser, genUser } from "../utils/genUser";
8+
import { insertVipUser } from "../utils/queryGen";
219

2210
async function dbSponsorTimesCompareExpect(db: IDatabase, videoId: string, expectdHidden: number) {
23-
const seg = await db.prepare("get", `SELECT "hidden", "UUID" FROM "sponsorTimes" WHERE "videoID" = ?`, [videoId]);
24-
for (let i = 0, len = seg.length; i < len; i++) {
25-
if (seg.hidden !== expectdHidden) {
26-
return `${seg.UUID} hidden expected to be ${expectdHidden} but found ${seg.hidden}`;
27-
}
28-
}
11+
const seg = await db.prepare("get", `SELECT "hidden", "UUID" FROM "sponsorTimes" WHERE "videoID" = ? AND "hidden" != ? `, [videoId, expectdHidden]);
12+
if (seg) return `${seg.UUID} expected to be ${expectdHidden} but found ${seg.hidden}}`;
2913
return;
3014
}
3115

3216
describe("postPurgeAllSegments", function () {
33-
const privateVipUserID = "VIPUser-purgeAll";
34-
const vipUserID = getHash(privateVipUserID);
3517
const endpoint = "/api/purgeAllSegments";
36-
const postSegmentShift = (videoID: string, userID: string) => client.post(endpoint, { videoID, userID });
18+
const postPurgeSegments = (videoID: string, userID: string) => client.post(endpoint, { videoID, userID });
19+
// users
20+
const vipUser = genUser("postPurgeAllSegments", "vipUser");
21+
const randomUser = genAnonUser();
22+
// videos
23+
const purgeID = "vsegpurge01";
24+
const identifier = "vsegpurgetest01";
3725

3826
before(async function () {
3927
// startTime and endTime get set in beforeEach for consistency
40-
await dbSponsorTimesAdd(db, "vsegpurge01", 0, 1, "vsegpurgetest01uuid01", "intro");
41-
await dbSponsorTimesAdd(db, "vsegpurge01", 0, 2, "vsegpurgetest01uuid02", "sponsor");
42-
await dbSponsorTimesAdd(db, "vsegpurge01", 0, 3, "vsegpurgetest01uuid03", "interaction");
43-
await dbSponsorTimesAdd(db, "vsegpurge01", 0, 4, "vsegpurgetest01uuid04", "outro");
44-
await dbSponsorTimesAdd(db, "vseg-not-purged01", 0, 5, "vsegpurgetest01uuid05", "outro");
45-
await db.prepare("run", `INSERT INTO "vipUsers" ("userID") VALUES (?)`, [vipUserID]);
28+
await insertSegment(db, { videoID: purgeID, category: "intro" }, identifier);
29+
await insertSegment(db, { videoID: purgeID, category: "sponsor" }, identifier);
30+
await insertSegment(db, { videoID: purgeID, category: "interaction" }, identifier);
31+
await insertSegment(db, { videoID: purgeID, category: "outro" }, identifier);
32+
await insertSegment(db, { videoID: "vseg-not-purged01", category: "outro" }, identifier);
33+
await insertVipUser(db, vipUser);
4634
});
4735

4836
it("Reject non-VIP user", function (done) {
49-
postSegmentShift("vsegpurge01", "segshift_randomuser001")
37+
postPurgeSegments(purgeID, randomUser.privID)
5038
.then(res => {
5139
assert.strictEqual(res.status, 403);
5240
done();
@@ -55,10 +43,10 @@ describe("postPurgeAllSegments", function () {
5543
});
5644

5745
it("Purge all segments success", function (done) {
58-
postSegmentShift("vsegpurge01", privateVipUserID)
46+
postPurgeSegments(purgeID, vipUser.privID)
5947
.then(async res => {
6048
assert.strictEqual(res.status, 200);
61-
done(await dbSponsorTimesCompareExpect(db, "vsegpurge01", 1) || await dbSponsorTimesCompareExpect(db, "vseg-not-purged01", 0));
49+
done(await dbSponsorTimesCompareExpect(db, purgeID, 1) || await dbSponsorTimesCompareExpect(db, "vseg-not-purged01", 0));
6250
})
6351
.catch(err => done(err));
6452
});

‎test/cases/setUsername.ts‎

Lines changed: 75 additions & 69 deletions
Original file line numberDiff line numberDiff line change
@@ -1,70 +1,62 @@
11
import { db, privateDB } from "../../src/databases/databases";
2-
import { getHash } from "../../src/utils/getHash";
32
import assert from "assert";
43
import { client } from "../utils/httpClient";
4+
import { UsernameUser, genAnonUser, genUsersUsername } from "../utils/genUser";
5+
import { genRandomValue } from "../utils/getRandom";
56

6-
const adminPrivateUserID = "testUserId";
7-
const user00PrivateUserID = "setUsername_00";
8-
const username00 = "Username 00";
9-
const user01PrivateUserID = "setUsername_01";
10-
const username01 = "Username 01";
11-
const user02PrivateUserID = "setUsername_02";
12-
const username02 = "Username 02";
13-
const user03PrivateUserID = "setUsername_03";
14-
const username03 = "Username 03";
15-
const user04PrivateUserID = "setUsername_04";
16-
const username04 = "Username 04";
17-
const user05PrivateUserID = "setUsername_05";
18-
const username05 = "Username 05";
19-
const user06PrivateUserID = "setUsername_06";
20-
const username06 = "Username 06";
21-
const user07PrivateUserID = "setUsername_07";
22-
const username07 = "Username 07";
23-
const user08PrivateUserID = "setUsername_08";
24-
25-
async function addUsername(userID: string, userName: string, locked = 0) {
26-
await db.prepare("run", 'INSERT INTO "userNames" ("userID", "userName", "locked") VALUES(?, ?, ?)', [userID, userName, locked]);
27-
await addLogUserNameChange(userID, userName);
7+
const adminPrivateUserID = "testUserId"; // hardcoded
8+
9+
const userMap = new Map();
10+
// generate usermap from 00 to 08
11+
for (let i = 0; i < 9; i++) {
12+
userMap.set(`user_0${i}`, `username_0${i}`);
2813
}
2914

30-
async function getUsernameInfo(userID: string): Promise<{ userName: string, locked: string}> {
31-
const row = await db.prepare("get", 'SELECT "userName", "locked" FROM "userNames" WHERE "userID" = ?', [userID]);
15+
const users = genUsersUsername("setUsername", userMap);
16+
17+
async function addUsername(user: UsernameUser, locked = 0) {
18+
await db.prepare("run", 'INSERT INTO "userNames" ("userID", "userName", "locked") VALUES(?, ?, ?)', [user.pubID, user.username, locked]);
19+
await addLogUserNameChange(user.pubID, user.username);
20+
}
21+
22+
async function getUsernameInfo(publicUserID: string): Promise<{ userName: string, locked: string}> {
23+
const row = await db.prepare("get", 'SELECT "userName", "locked" FROM "userNames" WHERE "userID" = ?', [publicUserID]);
3224
if (!row) {
3325
throw new Error("No username found");
3426
}
3527
return row;
3628
}
3729

38-
function addLogUserNameChange(userID: string, newUserName: string, oldUserName = "") {
30+
function addLogUserNameChange(publicUserID: string, newUserName: string, oldUserName = "") {
3931
privateDB.prepare("run",
4032
`INSERT INTO "userNameLogs"("userID", "newUserName", "oldUserName", "updatedAt", "updatedByAdmin") VALUES(?, ?, ?, ?, ?)`,
41-
[getHash(userID), newUserName, oldUserName, new Date().getTime(), + true]
33+
[publicUserID, newUserName, oldUserName, new Date().getTime(), + true]
4234
);
4335
}
4436

45-
function getLastLogUserNameChange(userID: string) {
46-
return privateDB.prepare("get", `SELECT * FROM "userNameLogs" WHERE "userID" = ? ORDER BY "updatedAt" DESC LIMIT 1`, [getHash(userID)]);
37+
function getLastLogUserNameChange(publicUserID: string) {
38+
return privateDB.prepare("get", `SELECT * FROM "userNameLogs" WHERE "userID" = ? ORDER BY "updatedAt" DESC LIMIT 1`, [publicUserID]);
4739
}
4840

4941
function wellFormatUserName(userName: string) {
5042
// eslint-disable-next-line no-control-regex
5143
return userName.replace(/[\u0000-\u001F\u007F-\u009F]/g, "");
5244
}
5345

54-
async function testUserNameChangelog(userID: string, newUserName: string, oldUserName: string, byAdmin: boolean, done: Mocha.Done) {
55-
const log = await getLastLogUserNameChange(userID);
46+
async function testUserNameChangelog(publicUserID: string, newUserName: string, oldUserName: string, byAdmin: boolean, done: Mocha.Done) {
47+
const log = await getLastLogUserNameChange(publicUserID);
5648
assert.strictEqual(newUserName, log.newUserName);
5749
assert.strictEqual(oldUserName, log.oldUserName);
5850
assert.strictEqual(byAdmin, Boolean(log.updatedByAdmin));
5951
return done();
6052
}
6153

6254
const endpoint = "/api/setUsername";
63-
const postSetUserName = (userID: string, username: string) => client({
55+
const postSetUserName = (privateUserID: string, username: string) => client({
6456
method: "POST",
6557
url: endpoint,
6658
params: {
67-
userID,
59+
userID: privateUserID,
6860
username,
6961
}
7062
});
@@ -81,33 +73,39 @@ const postSetUserNameAdmin = (userID: string, username: string, adminUserID: str
8173

8274
describe("setUsername", () => {
8375
before(async () => {
84-
await addUsername(getHash(user01PrivateUserID), username01, 0);
85-
await addUsername(getHash(user02PrivateUserID), username02, 0);
86-
await addUsername(getHash(user03PrivateUserID), username03, 0);
87-
await addUsername(getHash(user04PrivateUserID), username04, 1);
88-
await addUsername(getHash(user05PrivateUserID), username05, 0);
89-
await addUsername(getHash(user06PrivateUserID), username06, 0);
90-
await addUsername(getHash(user07PrivateUserID), username07, 1);
76+
// skip user0
77+
// add unlocked users
78+
await addUsername(users["user_01"], 0);
79+
await addUsername(users["user_02"], 0);
80+
await addUsername(users["user_03"], 0);
81+
await addUsername(users["user_05"], 0);
82+
await addUsername(users["user_06"], 0);
83+
await addUsername(users["user_08"], 0);
84+
// add locked users
85+
await addUsername(users["user_04"], 1);
86+
await addUsername(users["user_07"], 1);
9187
});
9288

9389
it("Should be able to set username that has never been set", (done) => {
94-
postSetUserName(user00PrivateUserID, username00)
90+
const user = users["user_00"];
91+
postSetUserName(user.privID, user.username)
9592
.then(async res => {
96-
const usernameInfo = await getUsernameInfo(getHash(user00PrivateUserID));
93+
const usernameInfo = await getUsernameInfo(user.pubID);
9794
assert.strictEqual(res.status, 200);
98-
assert.strictEqual(usernameInfo.userName, username00);
95+
assert.strictEqual(usernameInfo.userName, user.username);
9996
assert.notStrictEqual(usernameInfo.locked, 1, "username should not be locked");
10097
done();
10198
})
10299
.catch((err) => done(err));
103100
});
104101

105102
it("Should return 200", (done) => {
106-
const username = "Changed%20Username";
107-
postSetUserName(user01PrivateUserID, username)
103+
const user = users["user_01"];
104+
const newUsername = genRandomValue("username", "setUsername01");
105+
postSetUserName(user.privID, newUsername)
108106
.then(res => {
109107
assert.strictEqual(res.status, 200);
110-
testUserNameChangelog(user01PrivateUserID, username, username01, false, done);
108+
testUserNameChangelog(user.pubID, newUsername, user.username, false, done);
111109
})
112110
.catch((err) => done(err));
113111
});
@@ -143,8 +141,8 @@ describe("setUsername", () => {
143141
});
144142

145143
it('Should return 400 for "username" longer then 64 characters', (done) => {
146-
const username65 = "0000000000000000000000000000000000000000000000000000000000000000X";
147-
postSetUserName("test", username65)
144+
const username65 = "0".repeat(65);
145+
postSetUserName(genAnonUser().privID, username65)
148146
.then(res => {
149147
assert.strictEqual(res.status, 400);
150148
done();
@@ -154,10 +152,11 @@ describe("setUsername", () => {
154152

155153
it('Should not change username if it contains "discord"', (done) => {
156154
const newUsername = "discord.me";
157-
postSetUserName(user02PrivateUserID, newUsername)
155+
const user = users["user_02"];
156+
postSetUserName(user.privID, newUsername)
158157
.then(async res => {
159158
assert.strictEqual(res.status, 200);
160-
const userNameInfo = await getUsernameInfo(getHash(user02PrivateUserID));
159+
const userNameInfo = await getUsernameInfo(user.pubID);
161160
assert.notStrictEqual(userNameInfo.userName, newUsername);
162161
done();
163162
})
@@ -166,21 +165,23 @@ describe("setUsername", () => {
166165

167166
it("Should be able to change username", (done) => {
168167
const newUsername = "newUsername";
169-
postSetUserName(user03PrivateUserID, newUsername)
168+
const user = users["user_03"];
169+
postSetUserName(user.privID, newUsername)
170170
.then(async () => {
171-
const usernameInfo = await getUsernameInfo(getHash(user03PrivateUserID));
171+
const usernameInfo = await getUsernameInfo(user.pubID);
172172
assert.strictEqual(usernameInfo.userName, newUsername, "Username should change");
173173
assert.notStrictEqual(usernameInfo.locked, 1, "Username should not be locked");
174-
testUserNameChangelog(user03PrivateUserID, newUsername, username03, false, done);
174+
testUserNameChangelog(user.pubID, newUsername, user.username, false, done);
175175
})
176176
.catch((err) => done(err));
177177
});
178178

179179
it("Should not be able to change locked username", (done) => {
180180
const newUsername = "newUsername";
181-
postSetUserName(user04PrivateUserID, newUsername)
181+
const user = users["user_04"];
182+
postSetUserName(user.privID, newUsername)
182183
.then(async () => {
183-
const usernameInfo = await getUsernameInfo(getHash(user04PrivateUserID));
184+
const usernameInfo = await getUsernameInfo(user.pubID);
184185
assert.notStrictEqual(usernameInfo.userName, newUsername, "Username should not be changed");
185186
assert.strictEqual(usernameInfo.locked, 1, "username should be locked");
186187
done();
@@ -190,18 +191,21 @@ describe("setUsername", () => {
190191

191192
it("Should filter out unicode control characters", (done) => {
192193
const newUsername = "This\nUsername+has\tInvalid+Characters";
193-
postSetUserName(user05PrivateUserID, newUsername)
194+
const user = users["user_05"];
195+
postSetUserName(user.privID, newUsername)
194196
.then(async () => {
195-
const usernameInfo = await getUsernameInfo(getHash(user05PrivateUserID));
197+
const usernameInfo = await getUsernameInfo(user.pubID);
196198
assert.notStrictEqual(usernameInfo.userName, newUsername, "Username should not contain control characters");
197-
testUserNameChangelog(user05PrivateUserID, wellFormatUserName(newUsername), username05, false, done);
199+
testUserNameChangelog(user.pubID, wellFormatUserName(newUsername), user.username, false, done);
198200
})
199201
.catch((err) => done(err));
200202
});
201203

202204
it("Incorrect adminUserID should return 403", (done) => {
203205
const newUsername = "New Username";
204-
postSetUserNameAdmin(getHash(user06PrivateUserID), newUsername,"invalidAdminID")
206+
const user = users["user_06"];
207+
const adminID = genRandomValue("adminID", "setUsername06");
208+
postSetUserNameAdmin(user.pubID, newUsername, adminID)
205209
.then(res => {
206210
assert.strictEqual(res.status, 403);
207211
done();
@@ -211,34 +215,36 @@ describe("setUsername", () => {
211215

212216
it("Admin should be able to change username", (done) => {
213217
const newUsername = "New Username";
214-
postSetUserNameAdmin(getHash(user06PrivateUserID), newUsername, adminPrivateUserID)
218+
const user = users["user_06"];
219+
postSetUserNameAdmin(user.pubID, newUsername, adminPrivateUserID)
215220
.then(async () => {
216-
const usernameInfo = await getUsernameInfo(getHash(user06PrivateUserID));
221+
const usernameInfo = await getUsernameInfo(user.pubID);
217222
assert.strictEqual(usernameInfo.userName, newUsername, "username should be changed");
218223
assert.strictEqual(usernameInfo.locked, 1, "Username should be locked");
219-
testUserNameChangelog(user06PrivateUserID, newUsername, username06, true, done);
224+
testUserNameChangelog(user.pubID, newUsername, user.username, true, done);
220225
})
221226
.catch((err) => done(err));
222227
});
223228

224229
it("Admin should be able to change locked username", (done) => {
225230
const newUsername = "New Username";
226-
postSetUserNameAdmin(getHash(user07PrivateUserID), newUsername, adminPrivateUserID)
231+
const user = users["user_07"];
232+
postSetUserNameAdmin(user.pubID, newUsername, adminPrivateUserID)
227233
.then(async () => {
228-
const usernameInfo = await getUsernameInfo(getHash(user06PrivateUserID));
234+
const usernameInfo = await getUsernameInfo(user.pubID);
229235
assert.strictEqual(usernameInfo.userName, newUsername, "Username should be changed");
230236
assert.strictEqual(usernameInfo.locked, 1, "Username should be locked");
231-
testUserNameChangelog(user07PrivateUserID, newUsername, username07, true, done);
237+
testUserNameChangelog(user.pubID, newUsername, user.username, true, done);
232238
})
233239
.catch((err) => done(err));
234240
});
235241

236242
it("Should delete row if new username is same as publicID", (done) => {
237-
const publicID = getHash(user08PrivateUserID);
238-
postSetUserName(getHash(user08PrivateUserID), publicID)
243+
const user = users["user_08"];
244+
postSetUserName(user.privID, user.pubID)
239245
.then(() => {
240-
getUsernameInfo(getHash(user08PrivateUserID))
241-
.then(usernameinfo => done(`Username should be deleted - ${usernameinfo})`))
246+
getUsernameInfo(user.pubID)
247+
.then(usernameinfo => done(`Username should be deleted - ${JSON.stringify(usernameinfo)})`))
242248
.catch(() => done());
243249
})
244250
.catch((err) => done(err));

0 commit comments

Comments
 (0)