rename tests folder to the more accurate usecases

src/usecases/accept-invite.js

@@ -0,0 +1,41 @@
+/*
+Copyright 2018 New Vector Ltd
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+const assert = require('assert');
+const {acceptDialogMaybe} = require('./dialog');
+
+module.exports = async function acceptInvite(session, name) {
+    session.log.step(`accepts "${name}" invite`);
+    //TODO: brittle selector
+    const invitesHandles = await session.waitAndQueryAll('.mx_RoomTile_name.mx_RoomTile_invite');
+    const invitesWithText = await Promise.all(invitesHandles.map(async (inviteHandle) => {
+        const text = await session.innerText(inviteHandle);
+        return {inviteHandle, text};
+    }));
+    const inviteHandle = invitesWithText.find(({inviteHandle, text}) => {
+    return text.trim() === name;
+    }).inviteHandle;
+
+    await inviteHandle.click();
+
+    const acceptInvitationLink = await session.waitAndQuery(".mx_RoomPreviewBar_join_text a:first-child");
+    await acceptInvitationLink.click();
+
+    // accept e2e warning dialog
+    acceptDialogMaybe(session, "encryption");
+
+    session.log.done();
+}

src/usecases/consent.js

@@ -0,0 +1,27 @@
+/*
+Copyright 2018 New Vector Ltd
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+const assert = require('assert');
+
+module.exports = async function acceptTerms(session) {
+    const reviewTermsButton = await session.waitAndQuery('.mx_QuestionDialog button.mx_Dialog_primary');
+    const termsPagePromise = session.waitForNewPage();
+    await reviewTermsButton.click();
+    const termsPage = await termsPagePromise;
+    const acceptButton = await termsPage.$('input[type=submit]');
+    await acceptButton.click();
+    await session.delay(1000); //TODO yuck, timers
+}

src/usecases/create-room.js

@@ -0,0 +1,33 @@
+/*
+Copyright 2018 New Vector Ltd
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+const assert = require('assert');
+
+module.exports = async function createRoom(session, roomName) {
+    session.log.step(`creates room "${roomName}"`);
+    //TODO: brittle selector
+    const createRoomButton = await session.waitAndQuery('.mx_RoleButton[aria-label="Create new room"]');
+    await createRoomButton.click();
+
+    const roomNameInput = await session.waitAndQuery('.mx_CreateRoomDialog_input');
+    await session.replaceInputText(roomNameInput, roomName);
+
+    const createButton = await session.waitAndQuery('.mx_Dialog_primary');
+    await createButton.click();
+
+    await session.waitAndQuery('.mx_MessageComposer');
+    session.log.done();
+}

src/usecases/dialog.js

@@ -0,0 +1,47 @@
+/*
+Copyright 2018 New Vector Ltd
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+const assert = require('assert');
+
+
+async function acceptDialog(session, expectedContent) {
+    const foundDialog = await acceptDialogMaybe(session, expectedContent);
+    if (!foundDialog) {
+        throw new Error("could not find a dialog");
+    }
+}
+
+async function acceptDialogMaybe(session, expectedContent) {
+    let dialog = null;
+    try {
+        dialog = await session.waitAndQuery(".mx_QuestionDialog");
+    } catch(err) {
+        return false;
+    }
+    if (expectedContent) {
+        const contentElement = await dialog.$(".mx_Dialog_content");
+        const content = await (await contentElement.getProperty("innerText")).jsonValue();
+        assert.ok(content.indexOf(expectedContent) !== -1);
+    }
+    const primaryButton = await dialog.$(".mx_Dialog_primary");
+    await primaryButton.click();
+    return true;
+}
+
+module.exports = {
+    acceptDialog,
+    acceptDialogMaybe,
+};

src/usecases/invite.js

@@ -0,0 +1,30 @@
+/*
+Copyright 2018 New Vector Ltd
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+const assert = require('assert');
+
+module.exports = async function invite(session, userId) {
+    session.log.step(`invites "${userId}" to room`);
+    await session.delay(1000);
+    const inviteButton = await session.waitAndQuery(".mx_RightPanel_invite");
+    await inviteButton.click();
+    const inviteTextArea = await session.waitAndQuery(".mx_ChatInviteDialog textarea");
+    await inviteTextArea.type(userId);
+    await inviteTextArea.press("Enter");
+    const confirmButton = await session.query(".mx_Dialog_primary");
+    await confirmButton.click();
+    session.log.done();
+}

src/usecases/join.js

@@ -0,0 +1,36 @@
+/*
+Copyright 2018 New Vector Ltd
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+const assert = require('assert');
+
+module.exports = async function join(session, roomName) {
+    session.log.step(`joins room "${roomName}"`);
+    //TODO: brittle selector
+    const directoryButton = await session.waitAndQuery('.mx_RoleButton[aria-label="Room directory"]');
+    await directoryButton.click();
+
+    const roomInput = await session.waitAndQuery('.mx_DirectorySearchBox_input');
+    await session.replaceInputText(roomInput, roomName);
+
+    const firstRoomLabel = await session.waitAndQuery('.mx_RoomDirectory_table .mx_RoomDirectory_name:first-child', 1000);
+    await firstRoomLabel.click();
+
+    const joinLink = await session.waitAndQuery('.mx_RoomPreviewBar_join_text a');
+    await joinLink.click();
+
+    await session.waitAndQuery('.mx_MessageComposer');
+    session.log.done();
+}

src/usecases/room-settings.js

@@ -0,0 +1,90 @@
+/*
+Copyright 2018 New Vector Ltd
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+const assert = require('assert');
+const {acceptDialog} = require('./dialog');
+
+async function setCheckboxSetting(session, checkbox, enabled) {
+    const checked = await session.getElementProperty(checkbox, "checked");
+    assert.equal(typeof checked, "boolean");
+    if (checked !== enabled) {
+        await checkbox.click();
+        session.log.done();
+        return true;
+    } else {
+        session.log.done("already set");
+    }
+}
+
+module.exports = async function changeRoomSettings(session, settings) {
+    session.log.startGroup(`changes the room settings`);
+    /// XXX delay is needed here, possible because the header is being rerendered
+    /// click doesn't do anything otherwise
+    await session.delay(1000);
+    const settingsButton = await session.query(".mx_RoomHeader .mx_AccessibleButton[title=Settings]");
+    await settingsButton.click();
+    const checks = await session.waitAndQueryAll(".mx_RoomSettings_settings input[type=checkbox]");
+    assert.equal(checks.length, 3);
+    const e2eEncryptionCheck = checks[0];
+    const sendToUnverifiedDevices = checks[1];
+    const isDirectory = checks[2];
+
+    if (typeof settings.directory === "boolean") {
+        session.log.step(`sets directory listing to ${settings.directory}`);
+        await setCheckboxSetting(session, isDirectory, settings.directory);
+    }
+
+    if (typeof settings.encryption === "boolean") {
+        session.log.step(`sets room e2e encryption to ${settings.encryption}`);
+        const clicked = await setCheckboxSetting(session, e2eEncryptionCheck, settings.encryption);
+        // if enabling, accept beta warning dialog
+        if (clicked && settings.encryption) {
+            await acceptDialog(session, "encryption");
+        }
+    }
+
+    if (settings.visibility) {
+        session.log.step(`sets visibility to ${settings.visibility}`);
+        const radios = await session.waitAndQueryAll(".mx_RoomSettings_settings input[type=radio]");
+        assert.equal(radios.length, 7);
+        const inviteOnly = radios[0];
+        const publicNoGuests = radios[1];
+        const publicWithGuests = radios[2];
+
+        if (settings.visibility === "invite_only") {
+            await inviteOnly.click();
+        } else if (settings.visibility === "public_no_guests") {
+            await publicNoGuests.click();
+        } else if (settings.visibility === "public_with_guests") {
+            await publicWithGuests.click();
+        } else {
+            throw new Error(`unrecognized room visibility setting: ${settings.visibility}`);
+        }
+        session.log.done();
+    }
+
+    if (settings.alias) {
+        session.log.step(`sets alias to ${settings.alias}`);
+        const aliasField = await session.waitAndQuery(".mx_RoomSettings .mx_EditableItemList .mx_EditableItem_editable");
+        await session.replaceInputText(aliasField, settings.alias);
+        session.log.done();
+    }
+
+    const saveButton = await session.query(".mx_RoomHeader_wrapper .mx_RoomHeader_textButton");
+    await saveButton.click();
+
+    session.log.endGroup();
+}

src/usecases/send-message.js

@@ -0,0 +1,31 @@
+/*
+Copyright 2018 New Vector Ltd
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+const assert = require('assert');
+
+module.exports = async function sendMessage(session, message) {
+    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.
+    const composer = await session.waitAndQuery('.mx_MessageComposer_editor');
+    await composer.type(message);
+    const text = await session.innerText(composer);
+    assert.equal(text.trim(), message.trim());
+    await composer.press("Enter");
+    // wait for the message to appear sent
+    await session.waitAndQuery(".mx_EventTile_last:not(.mx_EventTile_sending)");
+    session.log.done();
+}

src/usecases/server-notices-consent.js

@@ -0,0 +1,31 @@
+/*
+Copyright 2018 New Vector Ltd
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+const assert = require('assert');
+const acceptInvite = require("./accept-invite")
+module.exports = async function acceptServerNoticesInviteAndConsent(session) {
+    await acceptInvite(session, "Server Notices");
+    session.log.step(`accepts terms & conditions`);
+    const consentLink = await session.waitAndQuery(".mx_EventTile_body a");
+    const termsPagePromise = session.waitForNewPage();
+    await consentLink.click();
+    const termsPage = await termsPagePromise;
+    const acceptButton = await termsPage.$('input[type=submit]');
+    await acceptButton.click();
+    await session.delay(1000); //TODO yuck, timers
+    await termsPage.close();
+    session.log.done();
+}

src/usecases/settings.js

@@ -0,0 +1,43 @@
+/*
+Copyright 2018 New Vector Ltd
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+const assert = require('assert');
+
+module.exports.enableLazyLoading = async function(session) {
+    session.log.step(`enables lazy loading of members in the lab settings`);
+    const settingsButton = await session.query('.mx_BottomLeftMenu_settings');
+    await settingsButton.click();
+    const llCheckbox = await session.waitAndQuery("#feature_lazyloading");
+    await llCheckbox.click();
+    await session.waitForReload();
+    const closeButton = await session.waitAndQuery(".mx_RoomHeader_cancelButton");
+    await closeButton.click();
+    session.log.done();
+}
+
+module.exports.getE2EDeviceFromSettings = async function(session) {
+    session.log.step(`gets e2e device/key from settings`);
+    const settingsButton = await session.query('.mx_BottomLeftMenu_settings');
+    await settingsButton.click();
+    const deviceAndKey = await session.waitAndQueryAll(".mx_UserSettings_section.mx_UserSettings_cryptoSection 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 closeButton = await session.query(".mx_RoomHeader_cancelButton");
+    await closeButton.click();
+    session.log.done();
+    return {id, key};
+}

src/usecases/signup.js

@@ -0,0 +1,69 @@
+/*
+Copyright 2018 New Vector Ltd
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+const acceptTerms = require('./consent');
+const assert = require('assert');
+
+module.exports = async function signup(session, username, password, homeserver) {
+    session.log.step("signs up");
+    await session.goto(session.url('/#/register'));
+    //click 'Custom server' radio button
+    if (homeserver) {
+        const advancedRadioButton = await session.waitAndQuery('#advanced');
+        await advancedRadioButton.click();
+    }
+    // wait until register button is visible
+    await session.waitAndQuery('.mx_Login_submit[value=Register]');
+    //fill out form
+    const loginFields = await session.queryAll('.mx_Login_field');
+    assert.strictEqual(loginFields.length, 7);
+    const usernameField = loginFields[2];
+    const passwordField = loginFields[3];
+    const passwordRepeatField = loginFields[4];
+    const hsurlField = loginFields[5];
+    await session.replaceInputText(usernameField, username);
+    await session.replaceInputText(passwordField, password);
+    await session.replaceInputText(passwordRepeatField, password);
+    if (homeserver) {
+        await session.waitAndQuery('.mx_ServerConfig');
+        await session.replaceInputText(hsurlField, homeserver);
+    }
+    //wait over a second because Registration/ServerConfig have a 1000ms
+    //delay to internally set the homeserver url
+    //see Registration::render and ServerConfig::props::delayTimeMs
+    await session.delay(1500);
+    /// focus on the button to make sure error validation
+    /// has happened before checking the form is good to go
+    const registerButton = await session.query('.mx_Login_submit');
+    await registerButton.focus();
+    //check no errors
+    const error_text = await session.tryGetInnertext('.mx_Login_error');
+    assert.strictEqual(!!error_text, false);
+    //submit form
+    //await page.screenshot({path: "beforesubmit.png", fullPage: true});
+    await registerButton.click();
+
+    //confirm dialog saying you cant log back in without e-mail
+    const continueButton = await session.waitAndQuery('.mx_QuestionDialog button.mx_Dialog_primary');
+    await continueButton.click();
+    //wait for registration to finish so the hash gets set
+    //onhashchange better?
+    await session.delay(2000);
+
+    const url = session.page.url();
+    assert.strictEqual(url, session.url('/#/home'));
+    session.log.done();
+}

src/usecases/timeline.js

@@ -0,0 +1,125 @@
+/*
+Copyright 2018 New Vector Ltd
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+const assert = require('assert');
+
+module.exports.scrollToTimelineTop = async function(session) {
+    session.log.step(`scrolls to the top of the timeline`);
+    await session.page.evaluate(() => {
+        return Promise.resolve().then(async () => {
+            const timelineScrollView = document.querySelector(".mx_RoomView .gm-scroll-view");
+            let timedOut = false;
+            let timeoutHandle = null;
+            // set scrollTop to 0 in a loop and check every 50ms
+            // if content became available (scrollTop not being 0 anymore),
+            // assume everything is loaded after 3s
+            do {
+                if (timelineScrollView.scrollTop !== 0) {
+                    if (timeoutHandle) {
+                        clearTimeout(timeoutHandle);
+                    }
+                    timeoutHandle = setTimeout(() => timedOut = true, 3000);
+                    timelineScrollView.scrollTop = 0;
+                } else {
+                    await new Promise((resolve) => setTimeout(resolve, 50));
+                }
+            } while (!timedOut)
+        });
+    })
+    session.log.done();
+}
+
+module.exports.receiveMessage = async function(session, expectedMessage) {
+    session.log.step(`receives message "${expectedMessage.body}" from ${expectedMessage.sender}`);
+    // wait for a response to come in that contains the message
+    // crude, but effective
+    await session.page.waitForResponse(async (response) => {
+        if (response.request().url().indexOf("/sync") === -1) {
+            return false;
+        }
+        const body = await response.text();
+        if (expectedMessage.encrypted) {
+            return body.indexOf(expectedMessage.sender) !== -1 &&
+                         body.indexOf("m.room.encrypted") !== -1;
+        } else {
+            return body.indexOf(expectedMessage.body) !== -1;
+        }
+    });
+    // wait a bit for the incoming event to be rendered
+    await session.delay(1000);
+    const lastTile = await getLastEventTile(session);
+    const foundMessage = await getMessageFromEventTile(lastTile);
+    assertMessage(foundMessage, expectedMessage);
+    session.log.done();
+}
+
+
+module.exports.checkTimelineContains = async function (session, expectedMessages, sendersDescription) {
+    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) => {
+        return getMessageFromEventTile(eventTile);
+    }));
+    //filter out tiles that were not messages
+    timelineMessages = timelineMessages .filter((m) => !!m);
+    expectedMessages.forEach((expectedMessage) => {
+        const foundMessage = timelineMessages.find((message) => {
+            return message.sender === expectedMessage.sender &&
+                   message.body === expectedMessage.body;
+        });
+        assertMessage(foundMessage, expectedMessage);
+    });
+
+    session.log.done();
+}
+
+function assertMessage(foundMessage, expectedMessage) {
+    assert(foundMessage, `message ${JSON.stringify(expectedMessage)} not found in timeline`);
+    assert.equal(foundMessage.body, expectedMessage.body);
+    assert.equal(foundMessage.sender, expectedMessage.sender);
+    if (expectedMessage.hasOwnProperty("encrypted")) {
+        assert.equal(foundMessage.encrypted, expectedMessage.encrypted);
+    }
+}
+
+function getLastEventTile(session) {
+    return session.query(".mx_EventTile_last");
+}
+
+function getAllEventTiles(session) {
+    return session.queryAll(".mx_RoomView_MessageList > *");
+}
+
+async function getMessageFromEventTile(eventTile) {
+    const senderElement = await eventTile.$(".mx_SenderProfile_name");
+    const bodyElement = await eventTile.$(".mx_EventTile_body");
+    let sender = null;
+    if (senderElement) {
+        sender = await(await senderElement.getProperty("innerText")).jsonValue();
+    }
+    if (!bodyElement) {
+        return null;
+    }
+    const body = await(await bodyElement.getProperty("innerText")).jsonValue();
+    const e2eIcon = await eventTile.$(".mx_EventTile_e2eIcon");
+
+    return {
+        sender,
+        body,
+        encrypted: !!e2eIcon
+    };
+}

src/usecases/verify-device.js

@@ -0,0 +1,42 @@
+/*
+Copyright 2018 New Vector Ltd
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+const assert = require('assert');
+
+module.exports = async function verifyDeviceForUser(session, name, expectedDevice) {
+    session.log.step(`verifies e2e device for ${name}`);
+    const memberNameElements = await session.queryAll(".mx_MemberList .mx_EntityTile_name");
+    const membersAndNames = await Promise.all(memberNameElements.map(async (el) => {
+        return [el, await session.innerText(el)];
+    }));
+    const matchingMember = membersAndNames.filter(([el, text]) => {
+        return text === name;
+    }).map(([el]) => el)[0];
+    await matchingMember.click();
+    const firstVerifyButton = await session.waitAndQuery(".mx_MemberDeviceInfo_verify");
+    await firstVerifyButton.click();
+    const dialogCodeFields = await session.waitAndQueryAll(".mx_QuestionDialog code");
+    assert.equal(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);
+    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();
+}