Revision control
Copy as Markdown
Other Tools
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
/**
* Tests that the UI is correctly updated at midnight.
*/
/* globals CalMetronome TodayPane */
const { cal } = ChromeUtils.importESModule("resource:///modules/calendar/calUtils.sys.mjs");
// UI elements that we want to test.
const minimonths = {
sidebar: document.getElementById("calMinimonth"),
todayPane: document.getElementById("today-minimonth"),
miniday: document.getElementById("miniday-dropdown-minimonth"),
};
const viewBox = document.getElementById("viewBox");
const views = {
day: document.getElementById("day-view"),
week: document.getElementById("week-view"),
multiweek: document.getElementById("multiweek-view"),
month: document.getElementById("month-view"),
};
// Dates that we need.
const now = cal.dtz.jsDateToDateTime(new Date()).getInTimezone(cal.dtz.UTC);
const closeToRealMidnight = now.hour == 23 && now.minute > 55;
now.isDate = true;
const today = {
year: now.year,
month: now.month,
day: now.day,
weekday: now.weekday,
weekdayName: cal.dtz.formatter.weekdayNames[now.weekday],
shortWeekdayName: cal.dtz.formatter.shortWeekdayNames[now.weekday],
calDate: now.clone(),
};
now.day--;
const yesterday = {
year: now.year,
month: now.month,
day: now.day,
weekday: now.weekday,
weekdayName: cal.dtz.formatter.weekdayNames[now.weekday],
shortWeekdayName: cal.dtz.formatter.shortWeekdayNames[now.weekday],
jsDate: cal.dtz.dateTimeToJsDate(now),
calDate: now.clone(),
};
now.day--;
const dayBeforeYesterday = {
year: now.year,
month: now.month,
day: now.day,
weekday: now.weekday,
weekdayName: cal.dtz.formatter.weekdayNames[now.weekday],
shortWeekdayName: cal.dtz.formatter.shortWeekdayNames[now.weekday],
jsDate: cal.dtz.dateTimeToJsDate(now),
calDate: now.clone(),
};
add_setup(async function () {
Assert.equal(
new Date().getDate(), // eslint-disable-line no-restricted-properties
today.day,
"This test will fail, because the local date and UTC date are not the same. You should be running this test in UTC."
);
cal.manager.getCalendars()[0].setProperty("disabled", false);
Assert.ok(BrowserTestUtils.isVisible(document.getElementById("today-pane-panel")));
});
add_task(function testReportIfCloseToMidnight() {
Assert.report(
false,
undefined,
undefined,
"This test didn't run, because the real UTC time is close to midnight, and that could cause it to fail."
);
}).skip(!closeToRealMidnight);
/**
* Tests that the calendar tab views are updated at midnight. The current day
* mark and selection should move.
*/
add_task(async function testViewsWithTodaySelected() {
// Check the state of the views, before the calendar tab opens.
// This test must run first.
checkMinimonthToday("sidebar", today);
checkMinimonthSelected("sidebar", today);
Assert.ok(minimonths.sidebar.showsToday);
for (const [name, view] of Object.entries(views)) {
Assert.strictEqual(
view.mToggleStatus,
undefined,
`${name} view should not be initialised at the start of the test`
);
}
// Open the views and check their state.
await checkDayViewToday("day", today);
await checkDayViewSelected("day", today);
await checkDayViewToday("week", today);
await checkDayViewSelected("week", today);
await checkMonthViewToday("multiweek", today);
await checkMonthViewSelected("multiweek", today);
await checkMonthViewToday("month", today);
await checkMonthViewSelected("month", today);
// Set things up as they would have been before midnight last night. Set
// `mShowsToday` to true to indicate that the selection should be follow the
// current day.
info("selecting yesterday");
minimonths.sidebar.value = yesterday.jsDate;
checkMinimonthToday("sidebar", today);
checkMinimonthSelected("sidebar", yesterday);
Assert.ok(!minimonths.sidebar.showsToday);
await checkDayViewSelected("day", yesterday);
await checkDayViewSelected("week", yesterday);
await checkMonthViewSelected("multiweek", yesterday);
await checkMonthViewSelected("month", yesterday);
info("changing the UI so that it needs updating");
minimonths.sidebar.mShowsToday = true;
clearTodayMarkers();
// Now emit the "day" event, as the metronome would do when it detects that
// the current day is not the same as it was last time events were emitted.
info("emitting midnight update");
CalMetronome.emit("day");
checkMinimonthToday("sidebar", today);
checkMinimonthSelected("sidebar", today);
Assert.ok(minimonths.sidebar.showsToday);
// Check the current view.
await checkMonthViewToday("month", today);
await checkMonthViewSelected("month", today);
// Without opening them, check the other views are marked as needing a refresh.
Assert.strictEqual(
views.day.mToggleStatus,
-1,
"day view status should be -1 after midnight update"
);
Assert.strictEqual(
views.week.mToggleStatus,
-1,
"week view status should be -1 after midnight update"
);
Assert.strictEqual(
views.multiweek.mToggleStatus,
-1,
"multiweek view status should be -1 after midnight update"
);
// Switch to the other views and check them.
await checkMonthViewToday("multiweek", today);
await checkMonthViewSelected("multiweek", today);
await checkDayViewToday("week", today);
await checkDayViewSelected("week", today);
await checkDayViewToday("day", today);
await checkDayViewSelected("day", today);
// Repeat with multiweek view selected.
info("retesting midnight update with multiweek view selected");
await CalendarTestUtils.setCalendarView(window, "multiweek");
minimonths.sidebar.value = yesterday.jsDate;
minimonths.sidebar.mShowsToday = true;
clearTodayMarkers();
CalMetronome.emit("day");
await checkMonthViewToday("multiweek", today);
await checkMonthViewSelected("multiweek", today);
// Repeat with week view selected.
info("retesting midnight update with week view selected");
await CalendarTestUtils.setCalendarView(window, "week");
minimonths.sidebar.value = yesterday.jsDate;
minimonths.sidebar.mShowsToday = true;
clearTodayMarkers();
CalMetronome.emit("day");
await checkDayViewToday("week", today);
await checkDayViewSelected("week", today);
// Repeat with day view selected.
info("retesting midnight update with day view selected");
await CalendarTestUtils.setCalendarView(window, "day");
minimonths.sidebar.value = yesterday.jsDate;
minimonths.sidebar.mShowsToday = true;
clearTodayMarkers();
CalMetronome.emit("day");
await checkDayViewToday("day", today);
await checkDayViewSelected("day", today);
await CalendarTestUtils.closeCalendarTab(window);
}).skip(closeToRealMidnight);
/**
* Tests that the calendar tab views are updated at midnight, when the
* current day is not selected. The current day mark should move, but not the
* selection.
*/
add_task(async function testViewsWithTodayNotSelected() {
// Now repeat the test, but this time don't set `mShowsToday`. The selected
// day should not change.
await CalendarTestUtils.openCalendarTab(window);
info("selecting the day before yesterday");
minimonths.sidebar.value = dayBeforeYesterday.jsDate;
checkMinimonthToday("sidebar", today);
checkMinimonthSelected("sidebar", dayBeforeYesterday);
Assert.ok(!minimonths.sidebar.showsToday);
await checkDayViewSelected("day", dayBeforeYesterday);
await checkDayViewSelected("week", dayBeforeYesterday);
await checkMonthViewSelected("multiweek", dayBeforeYesterday);
await checkMonthViewSelected("month", dayBeforeYesterday);
info("changing the UI so that it needs updating");
clearTodayMarkers();
// Now emit the "day" event, as the metronome would do when it detects that
// the current day is not the same as it was last time events were emitted.
info("emitting midnight update");
CalMetronome.emit("day");
checkMinimonthToday("sidebar", today);
checkMinimonthSelected("sidebar", dayBeforeYesterday);
Assert.ok(!minimonths.sidebar.showsToday);
// Check the current view.
await checkMonthViewToday("month", today, today.month != dayBeforeYesterday.month);
await checkMonthViewSelected("month", dayBeforeYesterday);
// Without opening them, check the other views are marked as needing a refresh.
Assert.strictEqual(
views.day.mToggleStatus,
-1,
"day view status should be -1 after midnight update"
);
Assert.strictEqual(
views.week.mToggleStatus,
-1,
"week view status should be -1 after midnight update"
);
Assert.strictEqual(
views.multiweek.mToggleStatus,
-1,
"multiweek view status should be -1 after midnight update"
);
// Switch to the other views and check them.
await checkMonthViewToday("multiweek", today, today.month != dayBeforeYesterday.month);
await checkMonthViewSelected("multiweek", dayBeforeYesterday);
await checkDayViewToday("week", dayBeforeYesterday.weekday <= 4 ? today : null);
await checkDayViewSelected("week", dayBeforeYesterday);
await checkDayViewToday("day", null);
await checkDayViewSelected("day", dayBeforeYesterday);
// Repeat with multiweek view selected.
info("retesting midnight update with multiweek view selected");
await CalendarTestUtils.setCalendarView(window, "multiweek");
minimonths.sidebar.value = dayBeforeYesterday.jsDate;
clearTodayMarkers();
CalMetronome.emit("day");
await checkMonthViewToday("multiweek", today, today.month != dayBeforeYesterday.month);
await checkMonthViewSelected("multiweek", dayBeforeYesterday);
// Repeat with week view selected.
info("retesting midnight update with week view selected");
await CalendarTestUtils.setCalendarView(window, "week");
minimonths.sidebar.value = dayBeforeYesterday.jsDate;
clearTodayMarkers();
CalMetronome.emit("day");
// Today won't be shown if it's in the week after the selected date,
// e.g. the selection is Saturday but today is Monday.
await checkDayViewToday("week", dayBeforeYesterday.weekday <= 4 ? today : null);
await checkDayViewSelected("week", dayBeforeYesterday);
// Repeat with day view selected.
info("retesting midnight update with day view selected");
await CalendarTestUtils.setCalendarView(window, "day");
minimonths.sidebar.value = dayBeforeYesterday.jsDate;
clearTodayMarkers();
CalMetronome.emit("day");
// Today won't be shown as it's not selected.
await checkDayViewToday("day", null);
await checkDayViewSelected("day", dayBeforeYesterday);
EventUtils.synthesizeMouseAtCenter(minimonths.sidebar.querySelector(".today-button"), {}, window);
await CalendarTestUtils.closeCalendarTab(window);
}).skip(closeToRealMidnight);
/**
* Tests that the today pane mini-month is updated at midnight. The current
* day mark and selection should move.
*/
add_task(async function testTodayPaneMinimonthWithTodaySelected() {
const todayPlus14 = today.calDate.clone();
todayPlus14.day += 14;
TodayPane.displayMiniSection("minimonth");
checkMinimonthToday("todayPane", today);
checkMinimonthSelected("todayPane", today);
Assert.ok(minimonths.todayPane.showsToday);
Assert.ok(TodayPane.showsToday);
Assert.equal(TodayPane.agenda.startDate.compare(today.calDate), 0);
Assert.equal(TodayPane.agenda.endDate.compare(todayPlus14), 0);
info("selecting yesterday");
minimonths.todayPane.value = yesterday.jsDate;
checkMinimonthToday("todayPane", today);
checkMinimonthSelected("todayPane", yesterday);
Assert.equal(TodayPane.agenda.startDate.compare(yesterday.calDate), 0);
Assert.equal(TodayPane.agenda.endDate.compare(today.calDate), 0);
Assert.ok(!minimonths.todayPane.showsToday);
Assert.ok(!TodayPane.showsToday);
info("changing the UI so that it needs updating");
minimonths.todayPane.mShowsToday = true;
TodayPane._showsToday = true;
minimonths.todayPane.querySelector("td[today]").removeAttribute("today");
minimonths.todayPane.mToday = null;
// Now emit the "day" event, as the metronome would do when it detects that
// the current day is not the same as it was last time events were emitted.
info("emitting midnight update");
CalMetronome.emit("day");
checkMinimonthToday("todayPane", today);
checkMinimonthSelected("todayPane", today);
Assert.ok(minimonths.todayPane.showsToday);
Assert.ok(TodayPane.showsToday);
Assert.equal(TodayPane.agenda.startDate.compare(today.calDate), 0);
Assert.equal(TodayPane.agenda.endDate.compare(todayPlus14), 0);
}).skip(closeToRealMidnight);
/**
* Tests that the today pane mini-month is updated at midnight. The current
* day mark should move, but not the selection.
*/
add_task(async function testTodayPaneMinimonthWithTodayNotSelected() {
const todayPlus14 = today.calDate.clone();
todayPlus14.day += 14;
TodayPane.displayMiniSection("minimonth");
checkMinimonthToday("todayPane", today);
checkMinimonthSelected("todayPane", today);
Assert.ok(minimonths.todayPane.showsToday);
Assert.ok(TodayPane.showsToday);
Assert.equal(TodayPane.agenda.startDate.compare(today.calDate), 0);
Assert.equal(TodayPane.agenda.endDate.compare(todayPlus14), 0);
info("selecting the day before yesterday");
minimonths.todayPane.value = dayBeforeYesterday.jsDate;
checkMinimonthToday("todayPane", today);
checkMinimonthSelected("todayPane", dayBeforeYesterday);
Assert.ok(!minimonths.todayPane.showsToday);
Assert.ok(!TodayPane.showsToday);
Assert.equal(TodayPane.agenda.startDate.compare(dayBeforeYesterday.calDate), 0);
Assert.equal(TodayPane.agenda.endDate.compare(yesterday.calDate), 0);
info("changing the UI so that it needs updating");
minimonths.todayPane.querySelector("td[today]").removeAttribute("today");
minimonths.todayPane.mToday = null;
// Now emit the "day" event, as the metronome would do when it detects that
// the current day is not the same as it was last time events were emitted.
info("emitting midnight update");
CalMetronome.emit("day");
checkMinimonthToday("todayPane", today);
checkMinimonthSelected("todayPane", dayBeforeYesterday);
Assert.ok(!minimonths.todayPane.showsToday);
Assert.ok(!TodayPane.showsToday);
Assert.equal(TodayPane.agenda.startDate.compare(dayBeforeYesterday.calDate), 0);
Assert.equal(TodayPane.agenda.endDate.compare(yesterday.calDate), 0);
EventUtils.synthesizeMouseAtCenter(
minimonths.todayPane.querySelector(".today-button"),
{},
window
);
}).skip(closeToRealMidnight);
/**
* Tests that the today pane mini-day is updated at midnight. The current
* day mark and selection should move.
*/
add_task(async function testTodayPaneMinidayWithTodaySelected() {
const todayPlus14 = today.calDate.clone();
todayPlus14.day += 14;
TodayPane.displayMiniSection("miniday");
const dayLabel = document.getElementById("datevalue-label");
const weekdayLabel = document.getElementById("weekdayNameLabel");
Assert.equal(dayLabel.value, today.day);
Assert.equal(weekdayLabel.value, today.shortWeekdayName);
checkMinimonthToday("miniday", today);
checkMinimonthSelected("miniday", today);
Assert.ok(TodayPane.showsToday);
Assert.equal(TodayPane.agenda.startDate.compare(today.calDate), 0);
Assert.equal(TodayPane.agenda.endDate.compare(todayPlus14), 0);
info("selecting yesterday");
EventUtils.synthesizeMouseAtCenter(document.getElementById("previous-day-button"), {}, window);
Assert.equal(dayLabel.value, yesterday.day);
Assert.equal(weekdayLabel.value, yesterday.shortWeekdayName);
checkMinimonthToday("miniday", today);
checkMinimonthSelected("miniday", yesterday);
Assert.ok(!TodayPane.showsToday);
Assert.equal(TodayPane.agenda.startDate.compare(yesterday.calDate), 0);
Assert.equal(TodayPane.agenda.endDate.compare(today.calDate), 0);
info("changing the UI so that it needs updating");
TodayPane._showsToday = true;
minimonths.miniday.querySelector("td[today]").removeAttribute("today");
minimonths.miniday.mToday = null;
// Now emit the "day" event, as the metronome would do when it detects that
// the current day is not the same as it was last time events were emitted.
info("emitting midnight update");
CalMetronome.emit("day");
Assert.equal(dayLabel.value, today.day);
Assert.equal(weekdayLabel.value, today.shortWeekdayName);
checkMinimonthToday("miniday", today);
checkMinimonthSelected("miniday", today);
Assert.ok(TodayPane.showsToday);
Assert.equal(TodayPane.agenda.startDate.compare(today.calDate), 0);
Assert.equal(TodayPane.agenda.endDate.compare(todayPlus14), 0);
}).skip(closeToRealMidnight);
/**
* Tests that the today pane mini-day is updated at midnight. The current
* day mark should move, but not the selection.
*/
add_task(async function testTodayPaneMinidayWithTodayNotSelected() {
const todayPlus14 = today.calDate.clone();
todayPlus14.day += 14;
TodayPane.displayMiniSection("miniday");
const dayLabel = document.getElementById("datevalue-label");
const weekdayLabel = document.getElementById("weekdayNameLabel");
Assert.equal(dayLabel.value, today.day);
Assert.equal(weekdayLabel.value, today.shortWeekdayName);
checkMinimonthToday("miniday", today);
checkMinimonthSelected("miniday", today);
Assert.ok(TodayPane.showsToday);
Assert.equal(TodayPane.agenda.startDate.compare(today.calDate), 0);
Assert.equal(TodayPane.agenda.endDate.compare(todayPlus14), 0);
info("selecting yesterday");
EventUtils.synthesizeMouseAtCenter(document.getElementById("previous-day-button"), {}, window);
EventUtils.synthesizeMouseAtCenter(document.getElementById("previous-day-button"), {}, window);
Assert.equal(dayLabel.value, dayBeforeYesterday.day);
Assert.equal(weekdayLabel.value, dayBeforeYesterday.shortWeekdayName);
checkMinimonthToday("miniday", today);
checkMinimonthSelected("miniday", dayBeforeYesterday);
Assert.ok(!TodayPane.showsToday);
Assert.equal(TodayPane.agenda.startDate.compare(dayBeforeYesterday.calDate), 0);
Assert.equal(TodayPane.agenda.endDate.compare(yesterday.calDate), 0);
info("changing the UI so that it needs updating");
minimonths.miniday.querySelector("td[today]").removeAttribute("today");
minimonths.miniday.mToday = null;
// Now emit the "day" event, as the metronome would do when it detects that
// the current day is not the same as it was last time events were emitted.
info("emitting midnight update");
CalMetronome.emit("day");
Assert.equal(dayLabel.value, dayBeforeYesterday.day);
Assert.equal(weekdayLabel.value, dayBeforeYesterday.shortWeekdayName);
checkMinimonthToday("miniday", today);
checkMinimonthSelected("miniday", dayBeforeYesterday);
Assert.ok(!TodayPane.showsToday);
Assert.equal(TodayPane.agenda.startDate.compare(dayBeforeYesterday.calDate), 0);
Assert.equal(TodayPane.agenda.endDate.compare(yesterday.calDate), 0);
EventUtils.synthesizeMouseAtCenter(document.getElementById("today-button"), {}, window);
}).skip(closeToRealMidnight);
/**
* Tests that the day number on the today pane button is updated at midnight.
*/
add_task(function () {
const todayButtonLabel = document.querySelector(
"#calendar-status-todaypane-button .toolbarbutton-day-text"
);
todayButtonLabel.textContent = "X";
// Now emit the "day" event, as the metronome would do when it detects that
// the current day is not the same as it was last time events were emitted.
info("emitting midnight update");
CalMetronome.emit("day");
Assert.equal(todayButtonLabel.textContent, today.day);
}).skip(closeToRealMidnight);
/**
* Remove all attributes used to indicate the current day.
*/
function clearTodayMarkers() {
minimonths.sidebar.querySelector("td[today]").removeAttribute("today");
minimonths.sidebar.mToday = null;
document.querySelectorAll("#view-box [relation]").forEach(e => e.removeAttribute("relation"));
}
/**
* Check the day marked as today in a mini-month is correct.
*
* @param {"sidebar"|"todayPane"|"miniday"} which
* @param {object} expected
*/
function checkMinimonthToday(which, expected) {
info(`checking ${which} minimonth today`);
const todays = minimonths[which].querySelectorAll("td[today]");
Assert.equal(todays.length, 1);
const todayInUTC = cal.dtz.jsDateToDateTime(todays[0].date, cal.dtz.UTC);
Assert.equal(todayInUTC.year, expected.year);
Assert.equal(todayInUTC.month, expected.month);
Assert.equal(todayInUTC.day, expected.day);
Assert.equal(todays[0].textContent, expected.day);
}
/**
* Check the selected day in a mini-month is correct.
*
* @param {"sidebar"|"todayPane"|"miniday"} which
* @param {object} expected
*/
function checkMinimonthSelected(which, expected) {
info(`checking ${which} minimonth selection`);
const selectedDays = minimonths[which].querySelectorAll("td[selected]");
Assert.equal(selectedDays.length, 1);
const selectedInUTC = cal.dtz.jsDateToDateTime(selectedDays[0].date, cal.dtz.UTC);
Assert.equal(selectedInUTC.year, expected.year);
Assert.equal(selectedInUTC.month, expected.month);
Assert.equal(selectedInUTC.day, expected.day);
Assert.equal(selectedDays[0].textContent, expected.day);
}
/**
* Check the day marked as today in a day or week view is correct.
*
* @param {"day"|"week"} which
* @param {object} expected
*/
async function checkDayViewToday(which, expected) {
info(`checking ${which} view today`);
await CalendarTestUtils.setCalendarView(window, which);
const todayLabels = views[which].querySelectorAll(".day-column-container.day-column-today");
if (!expected) {
Assert.equal(todayLabels.length, 0);
return;
}
Assert.equal(todayLabels.length, 1);
Assert.stringContains(todayLabels[0].textContent, `${expected.weekdayName} `);
Assert.stringContains(todayLabels[0].textContent, `${expected.shortWeekdayName} `);
Assert.stringContains(todayLabels[0].textContent, ` ${expected.day}`);
const dayLabels = [...views[which].querySelectorAll(".day-column-container")];
if (which == "day") {
Assert.equal(dayLabels.length, 1);
} else {
Assert.equal(dayLabels.length, 7);
Assert.equal(dayLabels.indexOf(todayLabels[0]), expected.weekday);
}
}
/**
* Check the selected day in a day or week view is correct.
*
* @param {"day"|"week"} which
* @param {object} expected
*/
async function checkDayViewSelected(which, expected) {
info(`checking ${which} view selection`);
await CalendarTestUtils.setCalendarView(window, which);
const selectedLabels = views[which].querySelectorAll(
which == "day" ? ".day-column-container" : ".day-column-container.day-column-selected"
);
Assert.equal(selectedLabels.length, 1);
Assert.stringContains(selectedLabels[0].textContent, `${expected.weekdayName} `);
Assert.stringContains(selectedLabels[0].textContent, `${expected.shortWeekdayName} `);
Assert.stringContains(selectedLabels[0].textContent, ` ${expected.day}`);
const dayLabels = [...views[which].querySelectorAll(".day-column-container")];
if (which == "day") {
Assert.equal(dayLabels.length, 1);
} else {
Assert.equal(dayLabels.length, 7);
Assert.equal(dayLabels.indexOf(selectedLabels[0]), expected.weekday);
}
}
/**
* Check the day marked as today in a multiweek or month view is correct.
*
* @param {"multiweek"|"month"} which
* @param {object} expected
* @param {bool} [isDifferentMonth=false] - If true, the selected date and
* today are in different months. Today might not be visible.
*/
async function checkMonthViewToday(which, expected, isDifferentMonth = false) {
info(`checking ${which} view today`);
await CalendarTestUtils.setCalendarView(window, which);
const todayLabels = views[which].querySelectorAll(`calendar-day-label[relation="today"]`);
Assert.equal(todayLabels.length, 1);
Assert.equal(todayLabels[0].firstElementChild.value, expected.weekdayName);
const dayLabels = [...views[which].querySelectorAll("calendar-day-label")];
Assert.equal(dayLabels.length, 7);
Assert.equal(dayLabels.indexOf(todayLabels[0]), expected.weekday);
const todayBoxes = views[which].querySelectorAll(`calendar-month-day-box[relation="today"]`);
if (which == "month" && isDifferentMonth && today.weekday <= 1) {
Assert.equal(todayBoxes.length, 0);
return;
}
Assert.equal(todayBoxes.length, 1);
Assert.equal(todayBoxes[0].getAttribute("year"), expected.year);
Assert.equal(todayBoxes[0].getAttribute("month"), expected.month + 1); // Not zero-indexed.
Assert.equal(todayBoxes[0].getAttribute("day"), expected.day);
const dayBoxes = [...todayBoxes[0].closest("tr").querySelectorAll("calendar-month-day-box")];
Assert.equal(dayBoxes.length, 7);
Assert.equal(dayBoxes.indexOf(todayBoxes[0]), expected.weekday);
if (expected.weekday > 0) {
Assert.equal(dayBoxes[0].getAttribute("relation"), "past");
}
if (expected.weekday < 6) {
Assert.equal(dayBoxes[6].getAttribute("relation"), "future");
}
}
/**
* Check the selected day in a multiweek or month view is correct.
*
* @param {"multiweek"|"month"} which
* @param {object} expected
*/
async function checkMonthViewSelected(which, expected) {
info(`checking ${which} view selection`);
await CalendarTestUtils.setCalendarView(window, which);
const selectedBoxes = views[which].querySelectorAll(`calendar-month-day-box[selected="true"]`);
Assert.equal(selectedBoxes.length, 1);
Assert.equal(selectedBoxes[0].getAttribute("year"), expected.year);
Assert.equal(selectedBoxes[0].getAttribute("month"), expected.month + 1); // Not zero-indexed.
Assert.equal(selectedBoxes[0].getAttribute("day"), expected.day);
const dayBoxes = [...selectedBoxes[0].closest("tr").querySelectorAll("calendar-month-day-box")];
Assert.equal(dayBoxes.length, 7);
Assert.equal(dayBoxes.indexOf(selectedBoxes[0]), expected.weekday);
}