Convert end-to-end tests to Typescript (#7206)

test/end-to-end-tests/src/usecases/accept-invite.ts

@@ -15,9 +15,10 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-const { findSublist } = require("./create-room");
+import { findSublist } from "./create-room";
+import { ElementSession } from "../session";
 
-module.exports = async function acceptInvite(session, name) {
+export async function acceptInvite(session: ElementSession, name: string): Promise<void> {
     session.log.step(`accepts "${name}" invite`);
     const inviteSublist = await findSublist(session, "invites");
     const invitesHandles = await inviteSublist.$$(".mx_RoomTile_name");
@@ -35,4 +36,4 @@ module.exports = async function acceptInvite(session, name) {
     await acceptInvitationLink.click();
 
     session.log.done();
-};
+}

test/end-to-end-tests/src/usecases/create-room.ts

@@ -15,18 +15,20 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-const { measureStart, measureStop } = require('../util');
+import { measureStart, measureStop } from '../util';
+import { ElementSession } from "../session";
+import * as puppeteer from "puppeteer";
 
-async function openRoomDirectory(session) {
+export async function openRoomDirectory(session: ElementSession): Promise<void> {
     const roomDirectoryButton = await session.query('.mx_LeftPanel_exploreButton');
     await roomDirectoryButton.click();
 }
 
-async function findSublist(session, name) {
+export async function findSublist(session: ElementSession, name: string): Promise<puppeteer.ElementHandle> {
     return await session.query(`.mx_RoomSublist[aria-label="${name}" i]`);
 }
 
-async function createRoom(session, roomName, encrypted=false) {
+export async function createRoom(session: ElementSession, roomName: string, encrypted = false): Promise<void> {
     session.log.step(`creates room "${roomName}"`);
 
     const roomsSublist = await findSublist(session, "rooms");
@@ -51,7 +53,7 @@ async function createRoom(session, roomName, encrypted=false) {
     session.log.done();
 }
 
-async function createDm(session, invitees) {
+export async function createDm(session: ElementSession, invitees: string[]): Promise<void> {
     session.log.step(`creates DM with ${JSON.stringify(invitees)}`);
 
     await measureStart(session, "mx_CreateDM");
@@ -83,5 +85,3 @@ async function createDm(session, invitees) {
 
     await measureStop(session, "mx_CreateDM");
 }
-
-module.exports = { openRoomDirectory, findSublist, createRoom, createDm };

test/end-to-end-tests/src/usecases/create-space.ts

@@ -14,12 +14,14 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-async function openSpaceCreateMenu(session) {
+import { ElementSession } from "../session";
+
+export async function openSpaceCreateMenu(session: ElementSession): Promise<void> {
     const spaceCreateButton = await session.query('.mx_SpaceButton_new');
     await spaceCreateButton.click();
 }
 
-async function createSpace(session, name, isPublic = false) {
+export async function createSpace(session: ElementSession, name: string, isPublic = false): Promise<void> {
     session.log.step(`creates space "${name}"`);
 
     await openSpaceCreateMenu(session);
@@ -50,7 +52,7 @@ async function createSpace(session, name, isPublic = false) {
     session.log.done();
 }
 
-async function inviteSpace(session, spaceName, userId) {
+export async function inviteSpace(session: ElementSession, spaceName: string, userId: string): Promise<void> {
     session.log.step(`invites "${userId}" to space "${spaceName}"`);
 
     const spaceButton = await session.query(`.mx_SpaceButton[aria-label="${spaceName}"]`);
@@ -76,5 +78,3 @@ async function inviteSpace(session, spaceName, userId) {
     await confirmButton.click();
     session.log.done();
 }
-
-module.exports = { openSpaceCreateMenu, createSpace, inviteSpace };

test/end-to-end-tests/src/usecases/dialog.ts

@@ -15,22 +15,23 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-const assert = require('assert');
+import { strict as assert } from 'assert';
+import { ElementSession } from "../session";
 
-async function assertDialog(session, expectedTitle) {
+export async function assertDialog(session: ElementSession, expectedTitle: string): Promise<void> {
     const titleElement = await session.query(".mx_Dialog .mx_Dialog_title");
     const dialogHeader = await session.innerText(titleElement);
     assert.equal(dialogHeader, expectedTitle);
 }
 
-async function acceptDialog(session, expectedTitle) {
+export async function acceptDialog(session: ElementSession, expectedTitle: string): Promise<void> {
     const foundDialog = await acceptDialogMaybe(session, expectedTitle);
     if (!foundDialog) {
         throw new Error("could not find a dialog");
     }
 }
 
-async function acceptDialogMaybe(session, expectedTitle) {
+export async function acceptDialogMaybe(session: ElementSession, expectedTitle: string): Promise<boolean> {
     let primaryButton = null;
     try {
         primaryButton = await session.query(".mx_Dialog .mx_Dialog_primary");
@@ -43,9 +44,3 @@ async function acceptDialogMaybe(session, expectedTitle) {
     await primaryButton.click();
     return true;
 }
-
-module.exports = {
-    assertDialog,
-    acceptDialog,
-    acceptDialogMaybe,
-};

test/end-to-end-tests/src/usecases/invite.ts

@@ -15,7 +15,9 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-module.exports = async function invite(session, userId) {
+import { ElementSession } from "../session";
+
+export async function invite(session: ElementSession, userId: string): Promise<void> {
     session.log.step(`invites "${userId}" to room`);
     await session.delay(1000);
     const memberPanelButton = await session.query(".mx_RightPanel_membersButton");
@@ -38,4 +40,4 @@ module.exports = async function invite(session, userId) {
     const confirmButton = await session.query(".mx_InviteDialog_goButton");
     await confirmButton.click();
     session.log.done();
-};
+}

test/end-to-end-tests/src/usecases/join.ts

@@ -15,10 +15,11 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-const { openRoomDirectory } = require('./create-room');
-const { measureStart, measureStop } = require('../util');
+import { openRoomDirectory } from './create-room';
+import { measureStart, measureStop } from '../util';
+import { ElementSession } from "../session";
 
-module.exports = async function join(session, roomName) {
+export async function join(session: ElementSession, roomName: string): Promise<void> {
     session.log.step(`joins room "${roomName}"`);
     await measureStart(session, "mx_JoinRoom");
     await openRoomDirectory(session);
@@ -30,4 +31,4 @@ module.exports = async function join(session, roomName) {
     await session.query('.mx_MessageComposer');
     await measureStop(session, "mx_JoinRoom");
     session.log.done();
-};
+}

test/end-to-end-tests/src/usecases/memberlist.ts

@@ -15,10 +15,12 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-const assert = require('assert');
-const { openRoomSummaryCard } = require("./rightpanel");
+import { strict as assert } from 'assert';
+import { openRoomSummaryCard } from "./rightpanel";
+import { ElementSession } from "../session";
+import { ElementHandle } from "puppeteer";
 
-async function openMemberInfo(session, name) {
+export async function openMemberInfo(session: ElementSession, name: String): Promise<void> {
     const membersAndNames = await getMembersInMemberlist(session);
     const matchingLabel = membersAndNames.filter((m) => {
         return m.displayName === name;
@@ -26,9 +28,13 @@ async function openMemberInfo(session, name) {
     await matchingLabel.click();
 }
 
-module.exports.openMemberInfo = openMemberInfo;
+interface Device {
+    id: string;
+    key: string;
+}
 
-module.exports.verifyDeviceForUser = async function(session, name, expectedDevice) {
+export async function verifyDeviceForUser(session: ElementSession, name: string,
+    expectedDevice: Device): Promise<void> {
     session.log.step(`verifies e2e device for ${name}`);
     const membersAndNames = await getMembersInMemberlist(session);
     const matchingLabel = membersAndNames.filter((m) => {
@@ -50,19 +56,24 @@ module.exports.verifyDeviceForUser = async function(session, name, expectedDevic
     console.log("my sas labels", sasLabels);
 
     const dialogCodeFields = await session.queryAll(".mx_QuestionDialog code");
-    assert.equal(dialogCodeFields.length, 2);
+    assert.strictEqual(dialogCodeFields.length, 2);
     const deviceId = await session.innerText(dialogCodeFields[0]);
     const deviceKey = await session.innerText(dialogCodeFields[1]);
-    assert.equal(expectedDevice.id, deviceId);
-    assert.equal(expectedDevice.key, deviceKey);
+    assert.strictEqual(expectedDevice.id, deviceId);
+    assert.strictEqual(expectedDevice.key, deviceKey);
     const confirmButton = await session.query(".mx_Dialog_primary");
     await confirmButton.click();
     const closeMemberInfo = await session.query(".mx_MemberInfo_cancel");
     await closeMemberInfo.click();
     session.log.done();
-};
+}
 
-async function getMembersInMemberlist(session) {
+interface MemberName {
+    label: ElementHandle;
+    displayName: string;
+}
+
+export async function getMembersInMemberlist(session: ElementSession): Promise<MemberName[]> {
     await openRoomSummaryCard(session);
     const memberPanelButton = await session.query(".mx_RoomSummaryCard_icon_people");
     // We are back at the room summary card
@@ -73,5 +84,3 @@ async function getMembersInMemberlist(session) {
         return { label: el, displayName: await session.innerText(el) };
     }));
 }
-
-module.exports.getMembersInMemberlist = getMembersInMemberlist;

test/end-to-end-tests/src/usecases/rightpanel.ts

@@ -14,7 +14,9 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-module.exports.openRoomRightPanel = async function(session) {
+import { ElementSession } from "../session";
+
+export async function openRoomRightPanel(session: ElementSession): Promise<void> {
     try {
         await session.query('.mx_RoomHeader .mx_RightPanel_headerButton_highlight[aria-label="Room Info"]');
     } catch (e) {
@@ -22,9 +24,9 @@ module.exports.openRoomRightPanel = async function(session) {
         const roomSummaryButton = await session.query('.mx_RoomHeader .mx_AccessibleButton[aria-label="Room Info"]');
         await roomSummaryButton.click();
     }
-};
+}
 
-module.exports.goBackToRoomSummaryCard = async function(session) {
+export async function goBackToRoomSummaryCard(session: ElementSession): Promise<void> {
     for (let i = 0; i < 5; i++) {
         try {
             const backButton = await session.query(".mx_BaseCard_back", 500);
@@ -39,9 +41,9 @@ module.exports.goBackToRoomSummaryCard = async function(session) {
             }
         }
     }
-};
+}
 
-module.exports.openRoomSummaryCard = async function(session) {
-    await module.exports.openRoomRightPanel(session);
-    await module.exports.goBackToRoomSummaryCard(session);
-};
+export async function openRoomSummaryCard(session: ElementSession) {
+    await openRoomRightPanel(session);
+    await goBackToRoomSummaryCard(session);
+}

test/end-to-end-tests/src/usecases/room-settings.ts

@@ -15,11 +15,13 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-const assert = require('assert');
-const { openRoomSummaryCard } = require("./rightpanel");
-const { acceptDialog } = require('./dialog');
+import { strict as assert } from 'assert';
+import { openRoomSummaryCard } from "./rightpanel";
+import { acceptDialog } from './dialog';
+import { ElementSession } from "../session";
+import { ElementHandle } from "puppeteer";
 
-async function setSettingsToggle(session, toggle, enabled) {
+export async function setSettingsToggle(session: ElementSession, toggle: ElementHandle, enabled): Promise<boolean> {
     const className = await session.getElementProperty(toggle, "className");
     const checked = className.includes("mx_ToggleSwitch_on");
     if (checked !== enabled) {
@@ -31,7 +33,8 @@ async function setSettingsToggle(session, toggle, enabled) {
     }
 }
 
-async function checkSettingsToggle(session, toggle, shouldBeEnabled) {
+export async function checkSettingsToggle(session: ElementSession,
+    toggle: ElementHandle, shouldBeEnabled: boolean): Promise<void> {
     const className = await session.getElementProperty(toggle, "className");
     const checked = className.includes("mx_ToggleSwitch_on");
     if (checked === shouldBeEnabled) {
@@ -42,7 +45,11 @@ async function checkSettingsToggle(session, toggle, shouldBeEnabled) {
     }
 }
 
-async function findTabs(session) {
+interface Tabs {
+    securityTabButton: ElementHandle;
+}
+
+async function findTabs(session: ElementSession): Promise<Tabs> {
     /// XXX delay is needed here, possibly because the header is being rerendered
     /// click doesn't do anything otherwise
     await session.delay(1000);
@@ -60,7 +67,14 @@ async function findTabs(session) {
     return { securityTabButton };
 }
 
-async function checkRoomSettings(session, expectedSettings) {
+interface Settings {
+    encryption: boolean;
+    directory?: boolean;
+    alias?: string;
+    visibility?: string;
+}
+
+export async function checkRoomSettings(session: ElementSession, expectedSettings: Settings): Promise<void> {
     session.log.startGroup(`checks the room settings`);
 
     const { securityTabButton } = await findTabs(session);
@@ -76,7 +90,7 @@ async function checkRoomSettings(session, expectedSettings) {
         session.log.step(`checks for local alias of ${expectedSettings.alias}`);
         const summary = await session.query(".mx_RoomSettingsDialog .mx_AliasSettings summary");
         await summary.click();
-        const localAliases = await session.query('.mx_RoomSettingsDialog .mx_AliasSettings .mx_EditableItem_item');
+        const localAliases = await session.queryAll('.mx_RoomSettingsDialog .mx_AliasSettings .mx_EditableItem_item');
         const localAliasTexts = await Promise.all(localAliases.map(a => session.innerText(a)));
         if (localAliasTexts.find(a => a.includes(expectedSettings.alias))) {
             session.log.done("present");
@@ -85,7 +99,7 @@ async function checkRoomSettings(session, expectedSettings) {
         }
     }
 
-    securityTabButton.click();
+    await securityTabButton.click();
     await session.delay(500);
     const securitySwitches = await session.queryAll(".mx_RoomSettingsDialog .mx_ToggleSwitch");
     const e2eEncryptionToggle = securitySwitches[0];
@@ -122,7 +136,7 @@ async function checkRoomSettings(session, expectedSettings) {
     session.log.endGroup();
 }
 
-async function changeRoomSettings(session, settings) {
+export async function changeRoomSettings(session, settings) {
     session.log.startGroup(`changes the room settings`);
 
     const { securityTabButton } = await findTabs(session);
@@ -179,5 +193,3 @@ async function changeRoomSettings(session, settings) {
 
     session.log.endGroup();
 }
-
-module.exports = { checkRoomSettings, changeRoomSettings };

test/end-to-end-tests/src/usecases/security.ts

@@ -14,9 +14,10 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-const { acceptToast } = require("./toasts");
+import { acceptToast } from "./toasts";
+import { ElementSession } from "../session";
 
-async function setupSecureBackup(session) {
+export async function setupSecureBackup(session: ElementSession): Promise<void> {
     session.log.step("sets up Secure Backup");
 
     await acceptToast(session, "Set up Secure Backup");

test/end-to-end-tests/src/usecases/send-message.ts

@@ -14,9 +14,10 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-const assert = require('assert');
+import { strict as assert } from 'assert';
+import { ElementSession } from "../session";
 
-module.exports = async function sendMessage(session, message) {
+export async function sendMessage(session: ElementSession, message: string): Promise<void> {
     session.log.step(`writes "${message}" in room`);
     // this selector needs to be the element that has contenteditable=true,
     // not any if its parents, otherwise it behaves flaky at best.
@@ -31,4 +32,4 @@ module.exports = async function sendMessage(session, message) {
     // wait for the message to appear sent
     await session.query(".mx_EventTile_last:not(.mx_EventTile_sending)");
     session.log.done();
-};
+}

test/end-to-end-tests/src/usecases/settings.ts

@@ -15,9 +15,10 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-const assert = require('assert');
+import { strict as assert } from 'assert';
+import { ElementSession } from "../session";
 
-async function openSettings(session, section) {
+export async function openSettings(session: ElementSession, section: string): Promise<void> {
     const menuButton = await session.query(".mx_UserMenu");
     await menuButton.click();
     const settingsItem = await session.query(".mx_UserMenu_iconSettings");
@@ -29,7 +30,7 @@ async function openSettings(session, section) {
     }
 }
 
-module.exports.enableLazyLoading = async function(session) {
+export async function enableLazyLoading(session: ElementSession): Promise<void> {
     session.log.step(`enables lazy loading of members in the lab settings`);
     const settingsButton = await session.query('.mx_BottomLeftMenu_settings');
     await settingsButton.click();
@@ -39,17 +40,22 @@ module.exports.enableLazyLoading = async function(session) {
     const closeButton = await session.query(".mx_RoomHeader_cancelButton");
     await closeButton.click();
     session.log.done();
-};
+}
 
-module.exports.getE2EDeviceFromSettings = async function(session) {
+interface E2EDevice {
+    id: string;
+    key: string;
+}
+
+export async function getE2EDeviceFromSettings(session: ElementSession): Promise<E2EDevice> {
     session.log.step(`gets e2e device/key from settings`);
     await openSettings(session, "security");
     const deviceAndKey = await session.queryAll(".mx_SettingsTab_section .mx_CryptographyPanel code");
     assert.equal(deviceAndKey.length, 2);
-    const id = await (await deviceAndKey[0].getProperty("innerText")).jsonValue();
-    const key = await (await deviceAndKey[1].getProperty("innerText")).jsonValue();
+    const id: string = await (await deviceAndKey[0].getProperty("innerText")).jsonValue();
+    const key: string = await (await deviceAndKey[1].getProperty("innerText")).jsonValue();
     const closeButton = await session.query(".mx_UserSettingsDialog .mx_Dialog_cancelButton");
     await closeButton.click();
     session.log.done();
     return { id, key };
-};
+}

test/end-to-end-tests/src/usecases/signup.ts

@@ -15,9 +15,11 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-const assert = require('assert');
+import { strict as assert } from 'assert';
+import { ElementSession } from "../session";
 
-module.exports = async function signup(session, username, password, homeserver) {
+export async function signup(session: ElementSession, username: string, password: string,
+    homeserver: string): Promise<void> {
     session.log.step("signs up");
     await session.goto(session.url('/#/register'));
     // change the homeserver by clicking the advanced section
@@ -79,4 +81,4 @@ module.exports = async function signup(session, username, password, homeserver)
     });
     assert(foundHomeUrl);
     session.log.done();
-};
+}

test/end-to-end-tests/src/usecases/timeline.ts

@@ -15,9 +15,11 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-const assert = require('assert');
+import { strict as assert } from 'assert';
+import { ElementSession } from "../session";
+import { ElementHandle } from "puppeteer";
 
-module.exports.scrollToTimelineTop = async function(session) {
+export async function scrollToTimelineTop(session: ElementSession): Promise<void> {
     session.log.step(`scrolls to the top of the timeline`);
     await session.page.evaluate(() => {
         return Promise.resolve().then(async () => {
@@ -41,14 +43,21 @@ module.exports.scrollToTimelineTop = async function(session) {
         });
     });
     session.log.done();
-};
+}
 
-module.exports.receiveMessage = async function(session, expectedMessage) {
+interface Message {
+    sender: string;
+    encrypted?: boolean;
+    body: string;
+    continuation?: boolean;
+}
+
+export async function receiveMessage(session: ElementSession, expectedMessage: Message): Promise<void> {
     session.log.step(`receives message "${expectedMessage.body}" from ${expectedMessage.sender}`);
     // wait for a response to come in that contains the message
     // crude, but effective
 
-    async function getLastMessage() {
+    async function getLastMessage(): Promise<Message> {
         const lastTile = await getLastEventTile(session);
         return getMessageFromEventTile(lastTile);
     }
@@ -67,25 +76,26 @@ module.exports.receiveMessage = async function(session, expectedMessage) {
     });
     assertMessage(lastMessage, expectedMessage);
     session.log.done();
-};
+}
 
-module.exports.checkTimelineContains = async function(session, expectedMessages, sendersDescription) {
+export async function checkTimelineContains(session: ElementSession, expectedMessages: Message[],
+    sendersDescription: string): Promise<void> {
     session.log.step(`checks timeline contains ${expectedMessages.length} ` +
         `given messages${sendersDescription ? ` from ${sendersDescription}`:""}`);
     const eventTiles = await getAllEventTiles(session);
-    let timelineMessages = await Promise.all(eventTiles.map((eventTile) => {
+    let timelineMessages: Message[] = await Promise.all(eventTiles.map((eventTile) => {
         return getMessageFromEventTile(eventTile);
     }));
     //filter out tiles that were not messages
     timelineMessages = timelineMessages.filter((m) => !!m);
-    timelineMessages.reduce((prevSender, m) => {
+    timelineMessages.reduce((prevSender: string, m) => {
         if (m.continuation) {
             m.sender = prevSender;
             return prevSender;
         } else {
             return m.sender;
         }
-    });
+    }, "");
 
     expectedMessages.forEach((expectedMessage) => {
         const foundMessage = timelineMessages.find((message) => {
@@ -101,9 +111,9 @@ module.exports.checkTimelineContains = async function(session, expectedMessages,
     });
 
     session.log.done();
-};
+}
 
-function assertMessage(foundMessage, expectedMessage) {
+function assertMessage(foundMessage: Message, expectedMessage: Message): void {
     assert(foundMessage, `message ${JSON.stringify(expectedMessage)} not found in timeline`);
     assert.equal(foundMessage.body, expectedMessage.body);
     assert.equal(foundMessage.sender, expectedMessage.sender);
@@ -112,17 +122,17 @@ function assertMessage(foundMessage, expectedMessage) {
     }
 }
 
-function getLastEventTile(session) {
+function getLastEventTile(session: ElementSession): Promise<ElementHandle> {
     return session.query(".mx_EventTile_last");
 }
 
-function getAllEventTiles(session) {
+function getAllEventTiles(session: ElementSession): Promise<ElementHandle[]> {
     return session.queryAll(".mx_RoomView_MessageList .mx_EventTile");
 }
 
-async function getMessageFromEventTile(eventTile) {
+async function getMessageFromEventTile(eventTile: ElementHandle): Promise<Message> {
     const senderElement = await eventTile.$(".mx_SenderProfile_displayName");
-    const className = await (await eventTile.getProperty("className")).jsonValue();
+    const className: string = await (await eventTile.getProperty("className")).jsonValue();
     const classNames = className.split(" ");
     const bodyElement = await eventTile.$(".mx_EventTile_body");
     let sender = null;
@@ -132,7 +142,7 @@ async function getMessageFromEventTile(eventTile) {
     if (!bodyElement) {
         return null;
     }
-    const body = await(await bodyElement.getProperty("innerText")).jsonValue();
+    const body: string = await(await bodyElement.getProperty("innerText")).jsonValue();
 
     return {
         sender,

test/end-to-end-tests/src/usecases/toasts.ts

@@ -14,9 +14,10 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-const assert = require('assert');
+import { strict as assert } from 'assert';
+import { ElementSession } from "../session";
 
-async function assertNoToasts(session) {
+export async function assertNoToasts(session: ElementSession): Promise<void> {
     try {
         await session.query('.mx_Toast_toast', 1000, true);
     } catch (e) {
@@ -26,22 +27,20 @@ async function assertNoToasts(session) {
     }
 }
 
-async function assertToast(session, expectedTitle) {
+export async function assertToast(session: ElementSession, expectedTitle: string): Promise<void> {
     const h2Element = await session.query('.mx_Toast_title h2');
     const toastTitle = await session.innerText(h2Element);
     assert.equal(toastTitle, expectedTitle);
 }
 
-async function acceptToast(session, expectedTitle) {
+export async function acceptToast(session: ElementSession, expectedTitle: string): Promise<void> {
     await assertToast(session, expectedTitle);
     const btn = await session.query('.mx_Toast_buttons .mx_AccessibleButton_kind_primary');
     await btn.click();
 }
 
-async function rejectToast(session, expectedTitle) {
+export async function rejectToast(session: ElementSession, expectedTitle: string): Promise<void> {
     await assertToast(session, expectedTitle);
     const btn = await session.query('.mx_Toast_buttons .mx_AccessibleButton_kind_danger_outline');
     await btn.click();
 }
-
-module.exports = { assertNoToasts, assertToast, acceptToast, rejectToast };

test/end-to-end-tests/src/usecases/verify.ts

@@ -15,10 +15,11 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-const assert = require('assert');
-const { openMemberInfo } = require("./memberlist");
+import { strict as assert } from 'assert';
+import { openMemberInfo } from "./memberlist";
+import { ElementSession } from "../session";
 
-async function startVerification(session, name) {
+export async function startVerification(session: ElementSession, name: string): Promise<void> {
     session.log.step("opens their opponent's profile and starts verification");
     await openMemberInfo(session, name);
     // click verify in member info
@@ -29,22 +30,22 @@ async function startVerification(session, name) {
     await session.delay(1000);
 
     // click 'start verification'
-    const startVerifyButton = await session.query('.mx_UserInfo_container .mx_AccessibleButton_kind_primary');
+    const startVerifyButton = await session.query('.mx_UserInfo_container .mx_UserInfo_startVerification');
     await startVerifyButton.click();
     session.log.done();
 }
 
-async function getSasCodes(session) {
+async function getSasCodes(session: ElementSession): Promise<string[]> {
     const sasLabelElements = await session.queryAll(
         ".mx_VerificationShowSas .mx_VerificationShowSas_emojiSas .mx_VerificationShowSas_emojiSas_label");
     const sasLabels = await Promise.all(sasLabelElements.map(e => session.innerText(e)));
     return sasLabels;
 }
 
-async function doSasVerification(session) {
+async function doSasVerification(session: ElementSession): Promise<string[]> {
     session.log.step("hunts for the emoji to yell at their opponent");
     const sasCodes = await getSasCodes(session);
-    session.log.done(sasCodes);
+    session.log.done(sasCodes.join("\n"));
 
     // Assume they match
     session.log.step("assumes the emoji match");
@@ -74,7 +75,7 @@ async function doSasVerification(session) {
     return sasCodes;
 }
 
-module.exports.startSasVerification = async function(session, name) {
+export async function startSasVerification(session: ElementSession, name: string): Promise<string[]> {
     session.log.startGroup("starts verification");
     await startVerification(session, name);
 
@@ -84,9 +85,9 @@ module.exports.startSasVerification = async function(session, name) {
     const sasCodes = await doSasVerification(session);
     session.log.endGroup();
     return sasCodes;
-};
+}
 
-module.exports.acceptSasVerification = async function(session, name) {
+export async function acceptSasVerification(session: ElementSession, name: string): Promise<string[]> {
     session.log.startGroup("accepts verification");
     const requestToast = await session.query('.mx_Toast_icon_verification');
 
@@ -110,4 +111,4 @@ module.exports.acceptSasVerification = async function(session, name) {
     const sasCodes = await doSasVerification(session);
     session.log.endGroup();
     return sasCodes;
-};
+}