Mirror/SponsorBlockServer
1
0
Fork 0
mirror of https://github.com/ajayyy/SponsorBlockServer.git synced 2026-01-27 12:50:47 +03:00
Code Issues Packages Projects Releases Wiki Activity

fix eslint for tests

Browse Source
This commit is contained in:
Michael C
2021-07-12 02:43:46 -04:00
parent c0b1d201ad
commit 8b3ffe5d0d
30 changed files with 3453 additions and 3475 deletions
Download Patch File Download Diff File Expand all files Collapse all files

532
test/cases/getUserID.ts
View File

@@ -1,316 +1,316 @@
import fetch from 'node-fetch';
import {Done, getbaseURL} from '../utils';
import {db} from '../../src/databases/databases';
import {getHash} from '../../src/utils/getHash';
import assert from 'assert';
import fetch from "node-fetch";
import {Done, getbaseURL} from "../utils";
import {db} from "../../src/databases/databases";
import {getHash} from "../../src/utils/getHash";
import assert from "assert";
describe('getUserID', () => {
describe("getUserID", () => {
before(async () => {
const insertUserNameQuery = 'INSERT INTO "userNames" ("userID", "userName") VALUES(?, ?)';
await db.prepare("run", insertUserNameQuery, [getHash("getuserid_user_01"), 'fuzzy user 01']);
await db.prepare("run", insertUserNameQuery, [getHash("getuserid_user_02"), 'fuzzy user 02']);
await db.prepare("run", insertUserNameQuery, [getHash("getuserid_user_03"), 'specific user 03']);
await db.prepare("run", insertUserNameQuery, [getHash("getuserid_user_04"), 'repeating']);
await db.prepare("run", insertUserNameQuery, [getHash("getuserid_user_05"), 'repeating']);
await db.prepare("run", insertUserNameQuery, [getHash("getuserid_user_01"), "fuzzy user 01"]);
await db.prepare("run", insertUserNameQuery, [getHash("getuserid_user_02"), "fuzzy user 02"]);
await db.prepare("run", insertUserNameQuery, [getHash("getuserid_user_03"), "specific user 03"]);
await db.prepare("run", insertUserNameQuery, [getHash("getuserid_user_04"), "repeating"]);
await db.prepare("run", insertUserNameQuery, [getHash("getuserid_user_05"), "repeating"]);
await db.prepare("run", insertUserNameQuery, [getHash("getuserid_user_06"), getHash("getuserid_user_06")]);
await db.prepare("run", insertUserNameQuery, [getHash("getuserid_user_07"), '0redos0']);
await db.prepare("run", insertUserNameQuery, [getHash("getuserid_user_08"), '%redos%']);
await db.prepare("run", insertUserNameQuery, [getHash("getuserid_user_09"), '_redos_']);
await db.prepare("run", insertUserNameQuery, [getHash("getuserid_user_10"), 'redos\\%']);
await db.prepare("run", insertUserNameQuery, [getHash("getuserid_user_11"), '\\\\\\']);
await db.prepare("run", insertUserNameQuery, [getHash("getuserid_user_12"), 'a']);
await db.prepare("run", insertUserNameQuery, [getHash("getuserid_user_07"), "0redos0"]);
await db.prepare("run", insertUserNameQuery, [getHash("getuserid_user_08"), "%redos%"]);
await db.prepare("run", insertUserNameQuery, [getHash("getuserid_user_09"), "_redos_"]);
await db.prepare("run", insertUserNameQuery, [getHash("getuserid_user_10"), "redos\\%"]);
await db.prepare("run", insertUserNameQuery, [getHash("getuserid_user_11"), "\\\\\\"]);
await db.prepare("run", insertUserNameQuery, [getHash("getuserid_user_12"), "a"]);
});
it('Should be able to get a 200', (done: Done) => {
fetch(getbaseURL() + '/api/userID?username=fuzzy+user+01')
.then(async res => {
assert.strictEqual(res.status, 200);
done();
})
.catch(err => done(err));
it("Should be able to get a 200", (done: Done) => {
fetch(`${getbaseURL()}/api/userID?username=fuzzy+user+01`)
.then(async res => {
assert.strictEqual(res.status, 200);
done();
})
.catch(err => done(err));
});
it('Should be able to get a 400 (No username parameter)', (done: Done) => {
fetch(getbaseURL() + '/api/userID')
.then(res => {
assert.strictEqual(res.status, 400);
done();
})
.catch(err => done(err));
it("Should be able to get a 400 (No username parameter)", (done: Done) => {
fetch(`${getbaseURL()}/api/userID`)
.then(res => {
assert.strictEqual(res.status, 400);
done();
})
.catch(err => done(err));
});
it('Should be able to get a 200 (username is public id)', (done: Done) => {
fetch(getbaseURL() + '/api/userID?username='+getHash("getuserid_user_06"))
.then(async res => {
assert.strictEqual(res.status, 200);
done();
})
.catch(err => done(err));
it("Should be able to get a 200 (username is public id)", (done: Done) => {
fetch(`${getbaseURL()}/api/userID?username=${getHash("getuserid_user_06")}`)
.then(async res => {
assert.strictEqual(res.status, 200);
done();
})
.catch(err => done(err));
});
it('Should be able to get a 400 (username longer than 64 chars)', (done: Done) => {
fetch(getbaseURL() + '/api/userID?username='+getHash("getuserid_user_06")+'0')
.then(res => {
assert.strictEqual(res.status, 400);
done();
})
.catch(err => done(err));
it("Should be able to get a 400 (username longer than 64 chars)", (done: Done) => {
fetch(`${getbaseURL()}/api/userID?username=${getHash("getuserid_user_06")}0`)
.then(res => {
assert.strictEqual(res.status, 400);
done();
})
.catch(err => done(err));
});
it('Should be able to get single username', (done: Done) => {
fetch(getbaseURL() + '/api/userID?username=fuzzy+user+01')
.then(async res => {
assert.strictEqual(res.status, 200);
const expected = [{
userName: "fuzzy user 01",
userID: getHash("getuserid_user_01")
}];
const data = await res.json();
assert.deepStrictEqual(data, expected);
done();
})
.catch(err => done(err));
it("Should be able to get single username", (done: Done) => {
fetch(`${getbaseURL()}/api/userID?username=fuzzy+user+01`)
.then(async res => {
assert.strictEqual(res.status, 200);
const expected = [{
userName: "fuzzy user 01",
userID: getHash("getuserid_user_01")
}];
const data = await res.json();
assert.deepStrictEqual(data, expected);
done();
})
.catch(err => done(err));
});
it('Should be able to get multiple fuzzy user info from start', (done: Done) => {
fetch(getbaseURL() + '/api/userID?username=fuzzy+user')
.then(async res => {
assert.strictEqual(res.status, 200);
const expected = [{
userName: "fuzzy user 01",
userID: getHash("getuserid_user_01")
}, {
userName: "fuzzy user 02",
userID: getHash("getuserid_user_02")
}];
const data = await res.json();
assert.deepStrictEqual(data, expected);
done();
})
.catch(err => done(err));
it("Should be able to get multiple fuzzy user info from start", (done: Done) => {
fetch(`${getbaseURL()}/api/userID?username=fuzzy+user`)
.then(async res => {
assert.strictEqual(res.status, 200);
const expected = [{
userName: "fuzzy user 01",
userID: getHash("getuserid_user_01")
}, {
userName: "fuzzy user 02",
userID: getHash("getuserid_user_02")
}];
const data = await res.json();
assert.deepStrictEqual(data, expected);
done();
})
.catch(err => done(err));
});
it('Should be able to get multiple fuzzy user info from middle', (done: Done) => {
fetch(getbaseURL() + '/api/userID?username=user')
.then(async res => {
assert.strictEqual(res.status, 200);
const expected = [{
userName: "fuzzy user 01",
userID: getHash("getuserid_user_01")
}, {
userName: "fuzzy user 02",
userID: getHash("getuserid_user_02")
}, {
userName: "specific user 03",
userID: getHash("getuserid_user_03")
}];
const data = await res.json();
assert.deepStrictEqual(data, expected);
done();
})
.catch(err => done(err));
it("Should be able to get multiple fuzzy user info from middle", (done: Done) => {
fetch(`${getbaseURL()}/api/userID?username=user`)
.then(async res => {
assert.strictEqual(res.status, 200);
const expected = [{
userName: "fuzzy user 01",
userID: getHash("getuserid_user_01")
}, {
userName: "fuzzy user 02",
userID: getHash("getuserid_user_02")
}, {
userName: "specific user 03",
userID: getHash("getuserid_user_03")
}];
const data = await res.json();
assert.deepStrictEqual(data, expected);
done();
})
.catch(err => done(err));
});
it('Should be able to get with public ID', (done: Done) => {
it("Should be able to get with public ID", (done: Done) => {
const userID = getHash("getuserid_user_06");
fetch(getbaseURL() + '/api/userID?username='+userID)
.then(async res => {
assert.strictEqual(res.status, 200);
const expected = [{
userName: userID,
userID
}];
const data = await res.json();
assert.deepStrictEqual(data, expected);
done();
})
.catch(err => done(err));
fetch(`${getbaseURL()}/api/userID?username=${userID}`)
.then(async res => {
assert.strictEqual(res.status, 200);
const expected = [{
userName: userID,
userID
}];
const data = await res.json();
assert.deepStrictEqual(data, expected);
done();
})
.catch(err => done(err));
});
it('Should be able to get with fuzzy public ID', (done: Done) => {
it("Should be able to get with fuzzy public ID", (done: Done) => {
const userID = getHash("getuserid_user_06");
fetch(getbaseURL() + '/api/userID?username='+userID.substr(10,60))
.then(async res => {
assert.strictEqual(res.status, 200);
const expected = [{
userName: userID,
userID
}];
const data = await res.json();
assert.deepStrictEqual(data, expected);
done();
})
.catch(err => done(err));
fetch(`${getbaseURL()}/api/userID?username=${userID.substr(10,60)}`)
.then(async res => {
assert.strictEqual(res.status, 200);
const expected = [{
userName: userID,
userID
}];
const data = await res.json();
assert.deepStrictEqual(data, expected);
done();
})
.catch(err => done(err));
});
it('Should be able to get repeating username', (done: Done) => {
fetch(getbaseURL() + '/api/userID?username=repeating')
.then(async res => {
assert.strictEqual(res.status, 200);
const expected = [{
userName: "repeating",
userID: getHash("getuserid_user_04")
}, {
userName: "repeating",
userID: getHash("getuserid_user_05")
}];
const data = await res.json();
assert.deepStrictEqual(data, expected);
done();
})
.catch(err => done(err));
it("Should be able to get repeating username", (done: Done) => {
fetch(`${getbaseURL()}/api/userID?username=repeating`)
.then(async res => {
assert.strictEqual(res.status, 200);
const expected = [{
userName: "repeating",
userID: getHash("getuserid_user_04")
}, {
userName: "repeating",
userID: getHash("getuserid_user_05")
}];
const data = await res.json();
assert.deepStrictEqual(data, expected);
done();
})
.catch(err => done(err));
});
it('Should be able to get repeating fuzzy username', (done: Done) => {
fetch(getbaseURL() + '/api/userID?username=peat')
.then(async res => {
assert.strictEqual(res.status, 200);
const expected = [{
userName: "repeating",
userID: getHash("getuserid_user_04")
}, {
userName: "repeating",
userID: getHash("getuserid_user_05")
}];
const data = await res.json();
assert.deepStrictEqual(data, expected);
done();
})
.catch(err => done(err));
it("Should be able to get repeating fuzzy username", (done: Done) => {
fetch(`${getbaseURL()}/api/userID?username=peat`)
.then(async res => {
assert.strictEqual(res.status, 200);
const expected = [{
userName: "repeating",
userID: getHash("getuserid_user_04")
}, {
userName: "repeating",
userID: getHash("getuserid_user_05")
}];
const data = await res.json();
assert.deepStrictEqual(data, expected);
done();
})
.catch(err => done(err));
});
it('should avoid ReDOS with _', (done: Done) => {
fetch(getbaseURL() + '/api/userID?username=_redos_')
.then(async res => {
assert.strictEqual(res.status, 200);
const expected = [{
userName: "_redos_",
userID: getHash("getuserid_user_09")
}];
const data = await res.json();
assert.deepStrictEqual(data, expected);
done();
})
.catch(err => done(err));
it("should avoid ReDOS with _", (done: Done) => {
fetch(`${getbaseURL()}/api/userID?username=_redos_`)
.then(async res => {
assert.strictEqual(res.status, 200);
const expected = [{
userName: "_redos_",
userID: getHash("getuserid_user_09")
}];
const data = await res.json();
assert.deepStrictEqual(data, expected);
done();
})
.catch(err => done(err));
});
it('should avoid ReDOS with %', (done: Done) => {
fetch(getbaseURL() + '/api/userID?username=%redos%')
.then(async res => {
assert.strictEqual(res.status, 200);
const expected = [{
userName: "%redos%",
userID: getHash("getuserid_user_08")
}];
const data = await res.json();
assert.deepStrictEqual(data, expected);
done();
})
.catch(err => done(err));
it("should avoid ReDOS with %", (done: Done) => {
fetch(`${getbaseURL()}/api/userID?username=%redos%`)
.then(async res => {
assert.strictEqual(res.status, 200);
const expected = [{
userName: "%redos%",
userID: getHash("getuserid_user_08")
}];
const data = await res.json();
assert.deepStrictEqual(data, expected);
done();
})
.catch(err => done(err));
});
it('should return 404 if escaped backslashes present', (done: Done) => {
fetch(getbaseURL() + '/api/userID?username=%redos\\\\_')
.then(res => {
assert.strictEqual(res.status, 404);
done();
})
.catch(err => done(err));
it("should return 404 if escaped backslashes present", (done: Done) => {
fetch(`${getbaseURL()}/api/userID?username=%redos\\\\_`)
.then(res => {
assert.strictEqual(res.status, 404);
done();
})
.catch(err => done(err));
});
it('should return 404 if backslashes present', (done: Done) => {
fetch(getbaseURL() + '/api/userID?username=\\%redos\\_')
.then(res => {
assert.strictEqual(res.status, 404);
done();
})
.catch(err => done(err));
it("should return 404 if backslashes present", (done: Done) => {
fetch(`${getbaseURL()}/api/userID?username=\\%redos\\_`)
.then(res => {
assert.strictEqual(res.status, 404);
done();
})
.catch(err => done(err));
});
it('should return user if just backslashes', (done: Done) => {
fetch(getbaseURL() + '/api/userID?username=\\\\\\')
.then(async res => {
assert.strictEqual(res.status, 200);
const expected = [{
userName: "\\\\\\",
userID: getHash("getuserid_user_11")
}];
const data = await res.json();
assert.deepStrictEqual(data, expected);
done();
})
.catch(err => done(err));
it("should return user if just backslashes", (done: Done) => {
fetch(`${getbaseURL()}/api/userID?username=\\\\\\`)
.then(async res => {
assert.strictEqual(res.status, 200);
const expected = [{
userName: "\\\\\\",
userID: getHash("getuserid_user_11")
}];
const data = await res.json();
assert.deepStrictEqual(data, expected);
done();
})
.catch(err => done(err));
});
it('should not allow usernames more than 64 characters', (done: Done) => {
fetch(getbaseURL() + '/api/userID?username='+'0'.repeat(65))
.then(res => {
assert.strictEqual(res.status, 400);
done();
})
.catch(err => done(err));
it("should not allow usernames more than 64 characters", (done: Done) => {
fetch(`${getbaseURL()}/api/userID?username=${"0".repeat(65)}`)
.then(res => {
assert.strictEqual(res.status, 400);
done();
})
.catch(err => done(err));
});
it('should not allow usernames less than 3 characters', (done: Done) => {
fetch(getbaseURL() + '/api/userID?username=aa')
.then(res => {
assert.strictEqual(res.status, 400);
done();
})
.catch(err => done(err));
it("should not allow usernames less than 3 characters", (done: Done) => {
fetch(`${getbaseURL()}/api/userID?username=aa`)
.then(res => {
assert.strictEqual(res.status, 400);
done();
})
.catch(err => done(err));
});
it('should allow exact match', (done: Done) => {
fetch(getbaseURL() + '/api/userID?username=a&exact=true')
.then(async res => {
assert.strictEqual(res.status, 200);
const expected = [{
userName: "a",
userID: getHash("getuserid_user_12")
}];
const data = await res.json();
assert.deepStrictEqual(data, expected);
done();
})
.catch(err => done(err));
it("should allow exact match", (done: Done) => {
fetch(`${getbaseURL()}/api/userID?username=a&exact=true`)
.then(async res => {
assert.strictEqual(res.status, 200);
const expected = [{
userName: "a",
userID: getHash("getuserid_user_12")
}];
const data = await res.json();
assert.deepStrictEqual(data, expected);
done();
})
.catch(err => done(err));
});
it('Should be able to get repeating username with exact username', (done: Done) => {
fetch(getbaseURL() + '/api/userID?username=repeating&exact=true')
.then(async res => {
assert.strictEqual(res.status, 200);
const expected = [{
userName: "repeating",
userID: getHash("getuserid_user_04")
}, {
userName: "repeating",
userID: getHash("getuserid_user_05")
}];
const data = await res.json();
assert.deepStrictEqual(data, expected);
done();
})
.catch(err => done(err));
it("Should be able to get repeating username with exact username", (done: Done) => {
fetch(`${getbaseURL()}/api/userID?username=repeating&exact=true`)
.then(async res => {
assert.strictEqual(res.status, 200);
const expected = [{
userName: "repeating",
userID: getHash("getuserid_user_04")
}, {
userName: "repeating",
userID: getHash("getuserid_user_05")
}];
const data = await res.json();
assert.deepStrictEqual(data, expected);
done();
})
.catch(err => done(err));
});
it('Should not get exact unless explicitly set to true', (done: Done) => {
fetch(getbaseURL() + '/api/userID?username=user&exact=1')
.then(async res => {
assert.strictEqual(res.status, 200);
const expected = [{
userName: "fuzzy user 01",
userID: getHash("getuserid_user_01")
}, {
userName: "fuzzy user 02",
userID: getHash("getuserid_user_02")
}, {
userName: "specific user 03",
userID: getHash("getuserid_user_03")
}];
const data = await res.json();
assert.deepStrictEqual(data, expected);
done();
})
.catch(err => done(err));
it("Should not get exact unless explicitly set to true", (done: Done) => {
fetch(`${getbaseURL()}/api/userID?username=user&exact=1`)
.then(async res => {
assert.strictEqual(res.status, 200);
const expected = [{
userName: "fuzzy user 01",
userID: getHash("getuserid_user_01")
}, {
userName: "fuzzy user 02",
userID: getHash("getuserid_user_02")
}, {
userName: "specific user 03",
userID: getHash("getuserid_user_03")
}];
const data = await res.json();
assert.deepStrictEqual(data, expected);
done();
})
.catch(err => done(err));
});
});