229 lines
11 KiB
TypeScript
229 lines
11 KiB
TypeScript
|
|
import { validateCrs,
|
|
validatePisCode,
|
|
validateReasonCode,
|
|
validateTiploc,
|
|
validateUuid,
|
|
validateHeadcode,
|
|
validateNlc,
|
|
validateStanox,
|
|
validateStation} from "./inputValidation";
|
|
import { ValidationError } from "../errors";
|
|
|
|
describe("PIS Validation Tests", () => {
|
|
test("PIS inputs of the correct format should return true", () => {
|
|
expect(validatePisCode(1234)).toBe(true);
|
|
expect(validatePisCode("0999")).toBe(true);
|
|
expect(validatePisCode(9343)).toBe(true);
|
|
})
|
|
|
|
test("PIS inputs of an invalid format should throw a ValidationError", () => {
|
|
expect(() => validatePisCode(21)).toThrow(ValidationError);
|
|
expect(() => validatePisCode("hoo")).toThrow(ValidationError);
|
|
expect(() => validatePisCode({test: "Value"})).toThrow(ValidationError);
|
|
})
|
|
})
|
|
|
|
describe("TIPLOC Validation Tests", () => {
|
|
test("TIPLOC inputs of the correct format should return true", () => {
|
|
expect(validateTiploc("elyy")).toBe(true);
|
|
expect(validateTiploc("STROUD")).toBe(true);
|
|
expect(validateTiploc("GLOSTER")).toBe(true);
|
|
expect(validateTiploc("PaDtOn")).toBe(true);
|
|
})
|
|
|
|
test("TIPLOC inputs of an invalid format should throw a ValidationError", () => {
|
|
expect(() => validateTiploc("wey")).toThrow(ValidationError);
|
|
expect(() => validateTiploc("PMS")).toThrow(ValidationError);
|
|
expect(() => validateTiploc(89)).toThrow(ValidationError);
|
|
expect(() => validateTiploc(["STROUD", "GLOSTER"])).toThrow(ValidationError);
|
|
})
|
|
})
|
|
|
|
describe("CRS Validation Tests", () => {
|
|
test("CRS inputs of the correct format should return true", () => {
|
|
expect(validateCrs("bth")).toBe(true);
|
|
expect(validateCrs("BTH")).toBe(true);
|
|
expect(validateCrs("PoA")).toBe(true);
|
|
});
|
|
|
|
test("CRS inputs of an invalid format should throw a ValidationError", () => {
|
|
expect(() => validateCrs("BATHSPA")).toThrow(ValidationError);
|
|
expect(() => validateCrs("popo")).toThrow(ValidationError);
|
|
expect(() => validateCrs("BT")).toThrow(ValidationError);
|
|
})
|
|
|
|
test("CRS inputs that are not strings should throw ValidationError", () => {
|
|
expect(() => validateCrs(34)).toThrow(ValidationError);
|
|
expect(() => validateCrs([])).toThrow(ValidationError);
|
|
expect(() => validateCrs({})).toThrow(ValidationError);
|
|
expect(() => validateCrs(null)).toThrow(ValidationError);
|
|
expect(() => validateCrs(undefined)).toThrow(ValidationError);
|
|
})
|
|
})
|
|
|
|
describe("NLC Validation Tests", () => {
|
|
test("NLC inputs that are valid should return true", () => {
|
|
expect(validateNlc(354300)).toBe(true);
|
|
expect(validateNlc("322962")).toBe(true);
|
|
expect(validateNlc(999999)).toBe(true);
|
|
expect(validateNlc("999999")).toBe(true);
|
|
expect(validateNlc(100000)).toBe(true);
|
|
expect(validateNlc("100000")).toBe(true);
|
|
})
|
|
|
|
test("NLC inputs that are out of range should throw ValidationError", () => {
|
|
expect(() => validateNlc(3543)).toThrow(ValidationError);
|
|
expect(() => validateNlc("3229")).toThrow(ValidationError);
|
|
expect(() => validateNlc(3543001)).toThrow(ValidationError);
|
|
expect(() => validateNlc("3543001")).toThrow(ValidationError);
|
|
expect(() => validateNlc(99999)).toThrow(ValidationError);
|
|
expect(() => validateNlc(1000001)).toThrow(ValidationError);
|
|
expect(() => validateNlc("99999")).toThrow(ValidationError);
|
|
expect(() => validateNlc("1000001")).toThrow(ValidationError);
|
|
})
|
|
|
|
test("NLC inputs that are not numeric should throw ValidationError", () => {
|
|
expect(() => validateNlc([])).toThrow(ValidationError);
|
|
expect(() => validateNlc({})).toThrow(ValidationError);
|
|
expect(() => validateNlc(null)).toThrow(ValidationError);
|
|
expect(() => validateNlc(undefined)).toThrow(ValidationError);
|
|
expect(() => validateNlc(false)).toThrow(ValidationError);
|
|
expect(() => validateNlc("3543ab")).toThrow(ValidationError);
|
|
})
|
|
})
|
|
|
|
describe("STANOX Validation Tests", () => {
|
|
test("STANOX inputs of the correct format should return true", () => {
|
|
expect(validateStanox(11234)).toBe(true);
|
|
expect(validateStanox("11234")).toBe(true);
|
|
expect(validateStanox("99999")).toBe(true);
|
|
expect(validateStanox(10000)).toBe(true);
|
|
expect(validateStanox("10000")).toBe(true);
|
|
expect(validateStanox("01234")).toBe(true);
|
|
})
|
|
|
|
test("STANOX inputs that are out of range should throw Validation Error", () => {
|
|
expect(() => validateStanox(9999)).toThrow(ValidationError);
|
|
expect(() => validateStanox("9999")).toThrow(ValidationError);
|
|
expect(() => validateStanox(0o1234)).toThrow(ValidationError);
|
|
expect(() => validateStanox("100000")).toThrow(ValidationError);
|
|
expect(() => validateStanox(100000)).toThrow(ValidationError);
|
|
})
|
|
|
|
test("STANOX inputs that are not numeric should throw ValidationError", () => {
|
|
expect(() => validateStanox([])).toThrow(ValidationError);
|
|
expect(() => validateStanox({})).toThrow(ValidationError);
|
|
expect(() => validateStanox(null)).toThrow(ValidationError);
|
|
expect(() => validateStanox(undefined)).toThrow(ValidationError);
|
|
expect(() => validateStanox(false)).toThrow(ValidationError);
|
|
expect(() => validateStanox("3543ab")).toThrow(ValidationError);
|
|
})
|
|
|
|
test("Station inputs that should pass validation", () => {
|
|
expect(() => validateStation("Heathrow Terminal 5")).toBe(true);
|
|
expect(() => validateStation("King's Cross")).toBe(true);
|
|
expect(() => validateStation("St Budeaux Ferry Road/Victoria Road")).toBe(true);
|
|
expect(() => validateStation("Queenstown Road (Battersea)")).toBe(true);
|
|
expect(() => validateStation("Rhoose Cardiff International Airport")).toBe(true);
|
|
expect(() => validateStation("Chappel & Wakes Colne")).toBe(true);
|
|
expect(() => validateStation("Duncraig")).toBe(true);
|
|
})
|
|
|
|
test("Station inputs that contain unusul characters or invalid types should throw ValidationError", () => {
|
|
expect(() => validateStation([])).toThrow(ValidationError);
|
|
expect(() => validateStation({})).toThrow(ValidationError);
|
|
expect(() => validateStation(null)).toThrow(ValidationError);
|
|
expect(() => validateStation(undefined)).toThrow(ValidationError);
|
|
expect(() => validateStation(false)).toThrow(ValidationError);
|
|
expect(() => validateStation("Br*ra")).toThrow(ValidationError);
|
|
expect(() => validateStation("DROP TABLE stations;--")).toThrow(ValidationError);
|
|
expect(() => validateStation("King's Cross; DELETE FROM users;")).toThrow(ValidationError);
|
|
expect(() => validateStation("St Pancras' OR '1'='1")).toThrow(ValidationError);
|
|
expect(() => validateStation("<script>alert('xss')</script>")).toThrow(ValidationError);
|
|
})
|
|
})
|
|
|
|
describe("UUID Validation Tests", () => {
|
|
test("UUID inputs that are valid v4-UUIDs should return true", () => {
|
|
expect(validateUuid("5c5db50b-91c8-440c-80af-afc7bb375b4b")).toBe(true);
|
|
expect(validateUuid("9a9a3849-bbcb-452c-a0db-599a53cb27f3")).toBe(true);
|
|
})
|
|
|
|
test("UUID inputs that are valid v1-UUIDs should return true", () => {
|
|
expect(validateUuid("e7dd36f0-ff86-11ef-9cd2-0242ac120002")).toBe(true);
|
|
expect(validateUuid("e052e8b6-ff87-11ef-9cd2-0242ac120002")).toBe(true);
|
|
})
|
|
|
|
test("UUID inputs that are valid v7-UUIDs should return true", () => {
|
|
expect(validateUuid("01958c36-8b96-7ff1-be2c-d1488273f5e0")).toBe(true);
|
|
expect(validateUuid("01958c3a-f9d0-7c6a-b510-6de0dd36a49a")).toBe(true);
|
|
})
|
|
|
|
test("UUID inputs that are a nil UUID should return true", () => {
|
|
expect(validateUuid("00000000-0000-0000-0000-000000000000")).toBe(true);
|
|
})
|
|
|
|
test("UUID inputs that are actually not UUIDs should throw ValidationError", () => {
|
|
expect(() => validateUuid("thisisjustastring")).toThrow(ValidationError);
|
|
expect(() => validateUuid(789)).toThrow(ValidationError);
|
|
})
|
|
})
|
|
|
|
describe("Reason Code Validation Tests", () => {
|
|
test("Reason codes that are valid numbers or strings should return true", () => {
|
|
expect(validateReasonCode("999")).toBe(true);
|
|
expect(validateReasonCode("100")).toBe(true);
|
|
expect(validateReasonCode(402)).toBe(true);
|
|
expect(validateReasonCode(100)).toBe(true);
|
|
expect(validateReasonCode(999)).toBe(true);
|
|
})
|
|
|
|
test("Reason codes that are out of range numbers should throw ValidationError", () => {
|
|
expect(() => validateReasonCode(99)).toThrow(ValidationError);
|
|
expect(() => validateReasonCode("1000")).toThrow(ValidationError);
|
|
expect(() => validateReasonCode(1000)).toThrow(ValidationError);
|
|
expect(() => validateReasonCode("99")).toThrow(ValidationError);
|
|
})
|
|
|
|
test("Reason code inputs that are non numeric values should throw ValidationError", () => {
|
|
expect(() => validateReasonCode("19f")).toThrow(ValidationError);
|
|
expect(() => validateReasonCode(null)).toThrow(ValidationError);
|
|
expect(() => validateReasonCode(true)).toThrow(ValidationError);
|
|
expect(() => validateReasonCode([])).toThrow(ValidationError);
|
|
expect(() => validateReasonCode({})).toThrow(ValidationError);
|
|
})
|
|
})
|
|
|
|
describe("Headcode Validation Tests", () => {
|
|
test("Headcodes of the valid format should return true", () => {
|
|
expect(validateHeadcode("1A23")).toBe(true);
|
|
expect(validateHeadcode("5t09")).toBe(true);
|
|
expect(validateHeadcode("0z70")).toBe(true);
|
|
expect(validateHeadcode("4A10")).toBe(true);
|
|
expect(validateHeadcode("0m00")).toBe(true);
|
|
expect(validateHeadcode("9I94")).toBe(true);
|
|
expect(validateHeadcode("5u41")).toBe(true);
|
|
expect(validateHeadcode("5U34")).toBe(true);
|
|
expect(validateHeadcode("1F34")).toBe(true);
|
|
})
|
|
|
|
test("Headcodes of an invalid format should throw ValidationError", () => {
|
|
expect(() => validateHeadcode("A212")).toThrow(ValidationError);
|
|
expect(() => validateHeadcode("a433")).toThrow(ValidationError);
|
|
expect(() => validateHeadcode(" 1F43 ")).toThrow(ValidationError);
|
|
expect(() => validateHeadcode("f43a")).toThrow(ValidationError);
|
|
expect(() => validateHeadcode("&ate")).toThrow(ValidationError);
|
|
expect(() => validateHeadcode("")).toThrow(ValidationError);
|
|
})
|
|
|
|
test("Headcode inputs that are not strings should throw ValidationError", () => {
|
|
expect(() => validateHeadcode(4322)).toThrow(ValidationError);
|
|
expect(() => validateHeadcode([])).toThrow(ValidationError);
|
|
expect(() => validateHeadcode({})).toThrow(ValidationError);
|
|
expect(() => validateHeadcode(undefined)).toThrow(ValidationError);
|
|
expect(() => validateHeadcode(null)).toThrow(ValidationError);
|
|
expect(() => validateHeadcode(true)).toThrow(ValidationError);
|
|
})
|
|
})
|