mirror of
https://github.com/Extended-Thunder/send-later.git
synced 2025-12-11 20:37:48 +01:00
538 lines
15 KiB
JavaScript
538 lines
15 KiB
JavaScript
exports.init = function () {
|
|
// // Example
|
|
// SLTests.AddTest("Test name", (input, expected) => {
|
|
// const result = input+"foobar";
|
|
// return (result === expected) ||`Expected "${expected}", got "${result}"`;
|
|
// }, ['arg1','arg1foobar']);
|
|
|
|
function testParseableDateTimeFormat(name, input, output) {
|
|
SLTests.AddTest(name, () => {
|
|
const result = SLTools.parseableDateTimeFormat(new Date(input));
|
|
return result == output || `Expected "${output}", got "${result}"`;
|
|
}, []);
|
|
}
|
|
|
|
testParseableDateTimeFormat(
|
|
"Test parseableDateTimeFormat (raw) 1",
|
|
"Jan 1 1998 04:03",
|
|
"Thu, 1 Jan 1998 04:03:00 -0800",
|
|
);
|
|
testParseableDateTimeFormat(
|
|
"Test parseableDateTimeFormat (raw) 2",
|
|
"Sun Feb 29 2000 15:03:00 GMT+2",
|
|
"Tue, 29 Feb 2000 05:03:00 -0800",
|
|
);
|
|
testParseableDateTimeFormat(
|
|
"Test parseableDateTimeFormat (raw) 3",
|
|
"Sun Mar 01 1998 15:03:00 GMT+2",
|
|
"Sun, 1 Mar 1998 05:03:00 -0800",
|
|
);
|
|
testParseableDateTimeFormat(
|
|
"Test parseableDateTimeFormat (raw) 4",
|
|
"Wed Apr 01 1998 15:03:00 GMT+2",
|
|
"Wed, 1 Apr 1998 05:03:00 -0800",
|
|
);
|
|
testParseableDateTimeFormat(
|
|
"Test parseableDateTimeFormat (raw) 5",
|
|
"May 1 1998 04:03",
|
|
"Fri, 1 May 1998 04:03:00 -0700",
|
|
);
|
|
testParseableDateTimeFormat(
|
|
"Test parseableDateTimeFormat (raw) 6",
|
|
"June 1 1998 04:03",
|
|
"Mon, 1 Jun 1998 04:03:00 -0700",
|
|
);
|
|
testParseableDateTimeFormat(
|
|
"Test parseableDateTimeFormat (raw) 7",
|
|
"July 1 1998 04:03",
|
|
"Wed, 1 Jul 1998 04:03:00 -0700",
|
|
);
|
|
testParseableDateTimeFormat(
|
|
"Test parseableDateTimeFormat (raw) 8",
|
|
"August 1 1998 04:03",
|
|
"Sat, 1 Aug 1998 04:03:00 -0700",
|
|
);
|
|
testParseableDateTimeFormat(
|
|
"Test parseableDateTimeFormat (raw) 9",
|
|
"September 1 1998 04:03",
|
|
"Tue, 1 Sep 1998 04:03:00 -0700",
|
|
);
|
|
testParseableDateTimeFormat(
|
|
"Test parseableDateTimeFormat (raw) 10",
|
|
"Oct 1 1998 04:03",
|
|
"Thu, 1 Oct 1998 04:03:00 -0700",
|
|
);
|
|
testParseableDateTimeFormat(
|
|
"Test parseableDateTimeFormat (raw) 11",
|
|
"Nov 1 1998 04:03",
|
|
"Sun, 1 Nov 1998 04:03:00 -0800",
|
|
);
|
|
testParseableDateTimeFormat(
|
|
"Test parseableDateTimeFormat (raw) 12",
|
|
"Dec 1 2098 04:03",
|
|
"Mon, 1 Dec 2098 04:03:00 -0800",
|
|
);
|
|
|
|
SLTests.AddTest(
|
|
"Test parseableDateTimeFormat (half-hour tz)",
|
|
() => {
|
|
let d = new Date('"Mon, 6 Sep 2021 07:28:10 -0700"');
|
|
d.getTimezoneOffset = () => -570;
|
|
let expected = "Mon, 6 Sep 2021 07:28:10 +0930";
|
|
let result = SLTools.RFC5322.format(d);
|
|
return result == expected || `Expected "${expected}", got "${result}"`;
|
|
},
|
|
[],
|
|
);
|
|
|
|
SLTests.AddTest(
|
|
"Test parseableDateTimeFormat (quarter-hour tz)",
|
|
() => {
|
|
let d = new Date('"Mon, 6 Sep 2021 07:28:10 -0700"');
|
|
d.getTimezoneOffset = () => 555;
|
|
let expected = "Mon, 6 Sep 2021 07:28:10 -0915";
|
|
let result = SLTools.RFC5322.format(d);
|
|
return result == expected || `Expected "${expected}", got "${result}"`;
|
|
},
|
|
[],
|
|
);
|
|
|
|
SLTests.AddTest(
|
|
"Timezone offset UTC +0000",
|
|
() => {
|
|
let d = new Date();
|
|
d.getTimezoneOffset = () => 0;
|
|
let result = SLTools.RFC5322.tz(d);
|
|
return result === "+0000" || `Expected "+0000", got "${result}"`;
|
|
},
|
|
[],
|
|
);
|
|
|
|
SLTests.AddTest(
|
|
"Local timezone offset comparison",
|
|
() => {
|
|
let d = new Date();
|
|
let rfc = SLTools.RFC5322.tz(d);
|
|
let match = d.toString().match(/[+-]\d\d\d\d/);
|
|
if (!match) return `Unable to parse date string: ${d.toString()}`;
|
|
else
|
|
return (
|
|
rfc === match[0] ||
|
|
`Timezone offset does not match: "${rfc}" != "${match[0]}"`
|
|
);
|
|
},
|
|
[],
|
|
);
|
|
|
|
SLTests.AddTest(
|
|
"Timezone offset positive/negative",
|
|
() => {
|
|
for (let m = 1; m < 12 * 60; m += 1) {
|
|
let d = new Date();
|
|
|
|
d.getTimezoneOffset = () => m;
|
|
let tz = SLTools.RFC5322.tz(d);
|
|
let sign = tz.substr(0, 1);
|
|
let hr = tz.substr(1, 2) | 0;
|
|
let min = tz.substr(3, 2) | 0;
|
|
if (sign != "-") return `Incorrect sign: ${tz}`;
|
|
if (hr < 0 || hr > 12) return `Invalid hour: ${tz}`;
|
|
if (min < 0 || min > 59) return `Invalid minute: ${tz}`;
|
|
if (m != hr * 60 + min)
|
|
return `Invalid timezone offset: ${tz} (${m} minutes)`;
|
|
|
|
d.getTimezoneOffset = () => -m;
|
|
let tz2 = SLTools.RFC5322.tz(d);
|
|
if (tz2 != "+" + tz.substr(1))
|
|
return `Invalid tz comparison: ${tz} vs ${tz2}`;
|
|
}
|
|
return true;
|
|
},
|
|
[],
|
|
);
|
|
|
|
SLTests.AddTest(
|
|
"RFC5322 short weekday names",
|
|
() => {
|
|
let d = new Date();
|
|
let days = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
|
|
|
|
for (let wd = 0; wd < days.length; wd++) {
|
|
d.getDay = () => wd;
|
|
let result = SLTools.RFC5322.dayOfWeek(d);
|
|
if (result !== days[wd])
|
|
return `Incorrect day of week. Expected "${days[wd]}", got "${result}"`;
|
|
}
|
|
return true;
|
|
},
|
|
[],
|
|
);
|
|
|
|
SLTests.AddTest(
|
|
"RFC5322 short month names",
|
|
() => {
|
|
let d = new Date();
|
|
let months = [
|
|
"Jan",
|
|
"Feb",
|
|
"Mar",
|
|
"Apr",
|
|
"May",
|
|
"Jun",
|
|
"Jul",
|
|
"Aug",
|
|
"Sep",
|
|
"Oct",
|
|
"Nov",
|
|
"Dec",
|
|
];
|
|
|
|
for (let mo = 0; mo < months.length; mo++) {
|
|
d.getMonth = () => mo;
|
|
let result = SLTools.RFC5322.month(d);
|
|
if (result !== months[mo])
|
|
return `Incorrect weekday. Expected "${months[mo]}", got "${result}"`;
|
|
}
|
|
return true;
|
|
},
|
|
[],
|
|
);
|
|
|
|
SLTests.AddTest(
|
|
"Test parseableDateTimeFormat (current time fallback)",
|
|
() => {
|
|
const result = SLTools.parseableDateTimeFormat();
|
|
const expected = SLTools.parseableDateTimeFormat(Date.now());
|
|
return (
|
|
SLTools.compareDateTimes(result, "==", expected, 100) ||
|
|
`Expected "${expected}", got "${result}"`
|
|
);
|
|
},
|
|
[],
|
|
);
|
|
|
|
SLTests.AddTest(
|
|
"Test parseableDateTimeFormat (relative time string)",
|
|
() => {
|
|
const result = SLTools.parseableDateTimeFormat("1 minute from now");
|
|
const expected = SLTools.parseableDateTimeFormat(
|
|
new Date(Date.now() + 60000),
|
|
);
|
|
return (
|
|
SLTools.compareDateTimes(result, "==", expected, 100) ||
|
|
`Expected "${expected}", got "${result}"`
|
|
);
|
|
},
|
|
[],
|
|
);
|
|
|
|
SLTests.AddTest(
|
|
"Test humanDateTimeFormat",
|
|
(input, expected) => {
|
|
const result = SLTools.humanDateTimeFormat(new Date(input));
|
|
return result == expected || `Expected "${expected}", got "${result}"`;
|
|
},
|
|
["Sun Feb 01 1998 15:03:00 GMT+2", "Sun, Feb 1, 1998, 5:03 AM"],
|
|
);
|
|
|
|
SLTests.AddTest(
|
|
"Test shortHumanDateTimeFormat",
|
|
(input, expected) => {
|
|
const result = SLTools.shortHumanDateTimeFormat(new Date(input));
|
|
return result == expected || `Expected "${expected}", got "${result}"`;
|
|
},
|
|
["Sun Feb 01 1998 15:03:00 GMT+2", "2/1/1998, 5:03 AM"],
|
|
);
|
|
|
|
SLTests.AddTest(
|
|
"Test customHumanDateTimeFormat",
|
|
(input, expected) => {
|
|
const result = SLTools.customHumanDateTimeFormat(
|
|
new Date(input[0]),
|
|
input[1],
|
|
);
|
|
return result == expected || `Expected "${expected}", got "${result}"`;
|
|
},
|
|
[["Sun Feb 01 1998 15:03:00 GMT+2", "%Y-%m-%d %H:%M"], "1998-02-01 05:03"],
|
|
);
|
|
|
|
SLTests.AddTest(
|
|
"Test getWkdayName Sunday",
|
|
(input, expected) => {
|
|
const result = SLTools.getWkdayName(input[0], input[1]);
|
|
return result == expected || `Expected "${expected}", got "${result}"`;
|
|
},
|
|
[[0, null], "Sunday"],
|
|
);
|
|
|
|
SLTests.AddTest(
|
|
"Test getWkdayName Tuesday long",
|
|
(input, expected) => {
|
|
const result = SLTools.getWkdayName(input[0], input[1]);
|
|
return result == expected || `Expected "${expected}", got "${result}"`;
|
|
},
|
|
[[2, "long"], "Tuesday"],
|
|
);
|
|
|
|
SLTests.AddTest(
|
|
"Test getWkdayName Wednesday short",
|
|
(input, expected) => {
|
|
const result = SLTools.getWkdayName(input[0], input[1]);
|
|
return result == expected || `Expected "${expected}", got "${result}"`;
|
|
},
|
|
[[3, "short"], "Wed"],
|
|
);
|
|
|
|
SLTests.AddTest(
|
|
"Test formatTime from number",
|
|
(input, expected) => {
|
|
const result = SLTools.formatTime(input[0], input[1]);
|
|
return result == expected || `Expected "${expected}", got "${result}"`;
|
|
},
|
|
[[new Date(2020, 5, 3, 6, 55).getTime(), true], "0655"],
|
|
);
|
|
|
|
SLTests.AddTest(
|
|
"Test formatTime from date",
|
|
(input, expected) => {
|
|
const result = SLTools.formatTime(input[0], input[1]);
|
|
return result == expected || `Expected "${expected}", got "${result}"`;
|
|
},
|
|
[[new Date(2020, 5, 3, 6, 5), false], "605"],
|
|
);
|
|
|
|
SLTests.AddTest(
|
|
"Test formatTime from string",
|
|
(input, expected) => {
|
|
const result = SLTools.formatTime(input[0], input[1]);
|
|
return result == expected || `Expected "${expected}", got "${result}"`;
|
|
},
|
|
[["4:02", true], "0402"],
|
|
);
|
|
|
|
function TestComparison(func, a, comparison, b, ignoreSec, expected) {
|
|
a = new Date(a);
|
|
b = new Date(b);
|
|
const result = func(a, comparison, b, ignoreSec);
|
|
return result === expected || `Expected "${expected}", got "${result}"`;
|
|
}
|
|
|
|
SLTests.AddTest("Test compareTimes a < b", TestComparison, [
|
|
SLTools.compareTimes,
|
|
"8/31/2020, 05:00:00 AM",
|
|
"<",
|
|
"8/30/2020, 07:00:00 AM",
|
|
false,
|
|
true,
|
|
]);
|
|
SLTests.AddTest("Test compareTimes a >= b", TestComparison, [
|
|
SLTools.compareTimes,
|
|
"8/31/2020, 05:00:00 AM",
|
|
"<=",
|
|
"8/30/2020, 05:00:00 AM",
|
|
false,
|
|
true,
|
|
]);
|
|
SLTests.AddTest("Test compareTimes a > b", TestComparison, [
|
|
SLTools.compareTimes,
|
|
"8/31/2020, 05:15:00 PM",
|
|
">",
|
|
"8/30/2020, 05:00:00 AM",
|
|
false,
|
|
true,
|
|
]);
|
|
SLTests.AddTest("Test compareTimes a >= b", TestComparison, [
|
|
SLTools.compareTimes,
|
|
"8/31/2020, 05:15:00 PM",
|
|
">=",
|
|
"8/30/2020, 05:15:00 AM",
|
|
false,
|
|
true,
|
|
]);
|
|
SLTests.AddTest("Test compareTimes a === b", TestComparison, [
|
|
SLTools.compareTimes,
|
|
"8/31/2019, 05:01:00 PM",
|
|
"===",
|
|
"8/30/2020, 05:01:00 PM",
|
|
false,
|
|
true,
|
|
]);
|
|
SLTests.AddTest("Test compareDates a < b differentmonth", TestComparison, [
|
|
SLTools.compareDates,
|
|
"7/31/2020, 09:01:00 AM",
|
|
"<",
|
|
"8/01/2020, 05:01:00 AM",
|
|
null,
|
|
true,
|
|
]);
|
|
SLTests.AddTest("Test compareDates ! a == b false", TestComparison, [
|
|
SLTools.compareDates,
|
|
"7/31/2020, 09:01:00 AM",
|
|
"==",
|
|
"8/01/2020, 05:01:00 AM",
|
|
null,
|
|
false,
|
|
]);
|
|
SLTests.AddTest("Test compareDates a == b false", TestComparison, [
|
|
SLTools.compareDates,
|
|
"7/31/2020, 09:01:00 AM",
|
|
"==",
|
|
"7/31/2020, 05:01:00 AM",
|
|
null,
|
|
true,
|
|
]);
|
|
SLTests.AddTest("Test compareDateTimes a === b !ignoreSec", TestComparison, [
|
|
SLTools.compareDateTimes,
|
|
"7/31/2020, 09:00:00 AM",
|
|
"===",
|
|
"7/31/2020, 09:00:20 AM",
|
|
false,
|
|
false,
|
|
]);
|
|
SLTests.AddTest("Test compareDateTimes a === b ignoreSec", TestComparison, [
|
|
SLTools.compareDateTimes,
|
|
"7/31/2020, 09:00:00 AM",
|
|
"===",
|
|
"7/31/2020, 09:00:20 AM",
|
|
true,
|
|
true,
|
|
]);
|
|
SLTests.AddTest(
|
|
"Test compareDateTimes a < b differentmonth",
|
|
TestComparison,
|
|
[
|
|
SLTools.compareDateTimes,
|
|
"7/31/2020, 09:01:00 AM",
|
|
"<",
|
|
"8/01/2020, 05:01:00 AM",
|
|
false,
|
|
true,
|
|
],
|
|
);
|
|
|
|
SLTests.AddTest(
|
|
"Test parseDateTime",
|
|
(dstr, tstr, expected) => {
|
|
const result = SLTools.parseDateTime(dstr, tstr);
|
|
return (
|
|
result.getTime() === expected.getTime() ||
|
|
`Expected "${expected}", got "${result}"`
|
|
);
|
|
},
|
|
["2015/01/17", "0130", new Date(2015, 0, 17, 1, 30)],
|
|
);
|
|
|
|
SLTests.AddTest(
|
|
"Test parseDateTime (time only)",
|
|
(input, expected) => {
|
|
const result = SLTools.parseDateTime(null, input);
|
|
return (
|
|
result.getTime() === expected.getTime() ||
|
|
`Expected "${expected}", got "${result}"`
|
|
);
|
|
},
|
|
["1:30", new Date(0, 0, 0, 1, 30)],
|
|
);
|
|
|
|
SLTests.AddTest(
|
|
"Test convertDate (text string relative)",
|
|
(input, expected) => {
|
|
const result = SLTools.convertDate(input, false);
|
|
return (
|
|
SLTools.compareDateTimes(result, "==", expected, 100) ||
|
|
`Expected "${expected.getTime()}", got "${result.getTime()}"`
|
|
);
|
|
},
|
|
["in 1 minute", new Date(Date.now() + 60000)],
|
|
);
|
|
|
|
SLTests.AddTest(
|
|
"Test convertDate (text string absolute)",
|
|
(input, expected) => {
|
|
const result = SLTools.convertDate(input);
|
|
return (
|
|
SLTools.compareDateTimes(result, "==", expected, 100) ||
|
|
`Expected "${expected.getTime()}", got "${result.getTime()}"`
|
|
);
|
|
},
|
|
["8/01/2020, 05:01:00 AM", new Date("8/01/2020, 05:01:00 AM")],
|
|
);
|
|
|
|
SLTests.AddTest(
|
|
"Test convertDate (number)",
|
|
(input, expected) => {
|
|
const result = SLTools.convertDate(input);
|
|
return (
|
|
SLTools.compareDateTimes(result, "==", expected, 100) ||
|
|
`Expected "${expected}", got "${result}"`
|
|
);
|
|
},
|
|
[Date.now(), new Date()],
|
|
);
|
|
|
|
SLTests.AddTest(
|
|
"Test convertDate (Date)",
|
|
(input, expected) => {
|
|
const result = SLTools.convertDate(input);
|
|
return (
|
|
SLTools.compareDateTimes(result, "==", expected, 100) ||
|
|
`Expected "${expected}", got "${result}"`
|
|
);
|
|
},
|
|
[new Date(), new Date()],
|
|
);
|
|
|
|
function compareRelativeTime(dateTime, relativeTo, expected) {
|
|
const result = SLTools.formatRelative(dateTime, relativeTo);
|
|
return result === expected || `Expected "${expected}", got "${result}"`;
|
|
}
|
|
|
|
SLTests.AddTest(
|
|
"Test relativeDateFormat '1 hour ago'",
|
|
compareRelativeTime,
|
|
[new Date(Date.now() - 3600 * 1000), null, "1 hour ago"],
|
|
);
|
|
|
|
SLTests.AddTest(
|
|
"Test relativeDateFormat '1 hour from now'",
|
|
compareRelativeTime,
|
|
[new Date(Date.now() + 3600 * 1000), null, "1 hour from now"],
|
|
);
|
|
|
|
SLTests.AddTest("Test relativeDateFormat '1 day ago'", compareRelativeTime, [
|
|
new Date(Date.now() - 3600 * 24 * 1000),
|
|
null,
|
|
"1 day ago",
|
|
]);
|
|
|
|
SLTests.AddTest(
|
|
"Test relativeDateFormat '7.5 hours from now'",
|
|
compareRelativeTime,
|
|
[new Date(Date.now() + 3600 * 7.5 * 1000), null, "7.5 hours from now"],
|
|
);
|
|
|
|
SLTests.AddTest(
|
|
"Test relativeDateFormat '0 seconds from now'",
|
|
compareRelativeTime,
|
|
[new Date(Date.now()), null, "0 seconds from now"],
|
|
);
|
|
|
|
SLTests.AddTest(
|
|
"Test relativeDateFormat '364 days from now'",
|
|
compareRelativeTime,
|
|
[new Date(Date.now() + 364 * 24 * 3600 * 1000), null, "364 days from now"],
|
|
);
|
|
|
|
SLTests.AddTest(
|
|
"Test relativeDateFormat (364.5 days) -> '1 year from now'",
|
|
compareRelativeTime,
|
|
[new Date(Date.now() + 364.5 * 24 * 3600 * 1000), null, "1 year from now"],
|
|
);
|
|
|
|
SLTests.AddTest(
|
|
"Test relativeDateFormat (90 seconds) -> '1.5 minutes from now'",
|
|
compareRelativeTime,
|
|
[new Date(Date.now() + 90 * 1000), null, "1.5 minutes from now"],
|
|
);
|
|
};
|