theluyuan
38ba663466
Some checks failed
Close stale issues and PRs / stale (push) Has been cancelled
504 lines
16 KiB
TypeScript
504 lines
16 KiB
TypeScript
import { P1, P3, Participant } from '../../helpers/Participant';
|
|
import { config } from '../../helpers/TestsConfig';
|
|
import {
|
|
ensureOneParticipant,
|
|
ensureThreeParticipants,
|
|
ensureTwoParticipants,
|
|
hangupAllParticipants
|
|
} from '../../helpers/participants';
|
|
import type { IJoinOptions } from '../../helpers/types';
|
|
import type PreMeetingScreen from '../../pageobjects/PreMeetingScreen';
|
|
|
|
describe('Lobby', () => {
|
|
it('joining the meeting', async () => {
|
|
await ensureOneParticipant();
|
|
|
|
if (!await ctx.p1.execute(() => APP.conference._room.isLobbySupported())) {
|
|
ctx.skipSuiteTests = true;
|
|
}
|
|
});
|
|
|
|
it('enable', async () => {
|
|
await ensureTwoParticipants();
|
|
|
|
await enableLobby();
|
|
});
|
|
|
|
it('entering in lobby and approve', async () => {
|
|
const { p1, p2 } = ctx;
|
|
|
|
await enterLobby(p1, true);
|
|
|
|
const { p3 } = ctx;
|
|
|
|
await p1.getNotifications().allowLobbyParticipant();
|
|
|
|
const notificationText = await p2.getNotifications().getLobbyParticipantAccessGranted();
|
|
|
|
expect(notificationText.includes(P1)).toBe(true);
|
|
expect(notificationText.includes(P3)).toBe(true);
|
|
|
|
await p2.getNotifications().closeLobbyParticipantAccessGranted();
|
|
|
|
// ensure 3 participants in the call will check for the third one that muc is joined, ice connected,
|
|
// media is being receiving and there are two remote streams
|
|
await p3.waitToJoinMUC();
|
|
await p3.waitForIceConnected();
|
|
await p3.waitForSendReceiveData();
|
|
await p3.waitForRemoteStreams(2);
|
|
|
|
// now check third one display name in the room, is the one set in the prejoin screen
|
|
const name = await p1.getFilmstrip().getRemoteDisplayName(await p3.getEndpointId());
|
|
|
|
expect(name).toBe(P3);
|
|
|
|
await p3.hangup();
|
|
});
|
|
|
|
it('entering in lobby and deny', async () => {
|
|
const { p1, p2 } = ctx;
|
|
|
|
// the first time tests is executed we need to enter display name,
|
|
// for next execution that will be locally stored
|
|
await enterLobby(p1, false);
|
|
|
|
// moderator rejects access
|
|
await p1.getNotifications().rejectLobbyParticipant();
|
|
|
|
// deny notification on 2nd participant
|
|
const notificationText = await p2.getNotifications().getLobbyParticipantAccessDenied();
|
|
|
|
expect(notificationText.includes(P1)).toBe(true);
|
|
expect(notificationText.includes(P3)).toBe(true);
|
|
|
|
await p2.getNotifications().closeLobbyParticipantAccessDenied();
|
|
|
|
const { p3 } = ctx;
|
|
|
|
// check the denied one is out of lobby, sees the notification about it
|
|
await p3.getNotifications().waitForLobbyAccessDeniedNotification();
|
|
|
|
expect(await p3.getLobbyScreen().isLobbyRoomJoined()).toBe(false);
|
|
|
|
await p3.hangup();
|
|
});
|
|
|
|
|
|
it('approve from participants pane', async () => {
|
|
const { p1 } = ctx;
|
|
|
|
const knockingParticipant = await enterLobby(p1, false);
|
|
|
|
// moderator allows access
|
|
const p1ParticipantsPane = p1.getParticipantsPane();
|
|
|
|
await p1ParticipantsPane.open();
|
|
await p1ParticipantsPane.admitLobbyParticipant(knockingParticipant);
|
|
await p1ParticipantsPane.close();
|
|
|
|
const { p3 } = ctx;
|
|
|
|
// ensure 3 participants in the call will check for the third one that muc is joined, ice connected,
|
|
// media is being receiving and there are two remote streams
|
|
await p3.waitToJoinMUC();
|
|
await p3.waitForIceConnected();
|
|
await p3.waitForSendReceiveData();
|
|
await p3.waitForRemoteStreams(2);
|
|
|
|
// now check third one display name in the room, is the one set in the prejoin screen
|
|
// now check third one display name in the room, is the one set in the prejoin screen
|
|
const name = await p1.getFilmstrip().getRemoteDisplayName(await p3.getEndpointId());
|
|
|
|
expect(name).toBe(P3);
|
|
|
|
await p3.hangup();
|
|
});
|
|
|
|
it('reject from participants pane', async () => {
|
|
const { p1 } = ctx;
|
|
|
|
const knockingParticipant = await enterLobby(p1, false);
|
|
|
|
// moderator rejects access
|
|
const p1ParticipantsPane = p1.getParticipantsPane();
|
|
|
|
await p1ParticipantsPane.open();
|
|
await p1ParticipantsPane.rejectLobbyParticipant(knockingParticipant);
|
|
await p1ParticipantsPane.close();
|
|
|
|
const { p3 } = ctx;
|
|
|
|
// check the denied one is out of lobby, sees the notification about it
|
|
// The third participant should see a warning that his access to the room was denied
|
|
await p3.getNotifications().waitForLobbyAccessDeniedNotification();
|
|
|
|
// check Lobby room not left
|
|
expect(await p3.getLobbyScreen().isLobbyRoomJoined()).toBe(false);
|
|
|
|
await p3.hangup();
|
|
});
|
|
|
|
it('lobby user leave', async () => {
|
|
const { p1 } = ctx;
|
|
|
|
await enterLobby(p1, false);
|
|
|
|
await ctx.p3.hangup();
|
|
|
|
// check that moderator (participant 1) no longer sees notification about participant in lobby
|
|
await p1.getNotifications().waitForHideOfKnockingParticipants();
|
|
});
|
|
|
|
it('conference ended in lobby', async () => {
|
|
const { p1, p2 } = ctx;
|
|
|
|
await enterLobby(p1, false);
|
|
|
|
await p1.hangup();
|
|
await p2.hangup();
|
|
|
|
const { p3 } = ctx;
|
|
|
|
await p3.driver.$('.dialog.leaveReason').isExisting();
|
|
|
|
await p3.driver.waitUntil(
|
|
async () => !await p3.getLobbyScreen().isLobbyRoomJoined(),
|
|
{
|
|
timeout: 2000,
|
|
timeoutMsg: 'p2 did not leave lobby'
|
|
}
|
|
);
|
|
|
|
await p3.hangup();
|
|
});
|
|
|
|
it('disable while participant in lobby', async () => {
|
|
await ensureTwoParticipants();
|
|
|
|
const { p1 } = ctx;
|
|
|
|
await enableLobby();
|
|
await enterLobby(p1);
|
|
|
|
const p1SecurityDialog = p1.getSecurityDialog();
|
|
|
|
await p1.getToolbar().clickSecurityButton();
|
|
await p1SecurityDialog.waitForDisplay();
|
|
|
|
await p1SecurityDialog.toggleLobby();
|
|
await p1SecurityDialog.waitForLobbyEnabled(true);
|
|
|
|
const { p3 } = ctx;
|
|
|
|
await p3.waitToJoinMUC();
|
|
|
|
expect(await p3.getLobbyScreen().isLobbyRoomJoined()).toBe(false);
|
|
});
|
|
|
|
it('change of moderators in lobby', async () => {
|
|
// no moderator switching if jaas is available.
|
|
if (config.iframe.usesJaas) {
|
|
return;
|
|
}
|
|
await hangupAllParticipants();
|
|
|
|
await ensureTwoParticipants();
|
|
|
|
const { p1, p2 } = ctx;
|
|
|
|
// hanging up the first one, which is moderator and second one should be
|
|
await p1.hangup();
|
|
|
|
await p2.driver.waitUntil(
|
|
() => p2.isModerator(),
|
|
{
|
|
timeout: 3000,
|
|
timeoutMsg: 'p2 is not moderator after p1 leaves'
|
|
}
|
|
);
|
|
|
|
const p2SecurityDialog = p2.getSecurityDialog();
|
|
|
|
await p2.getToolbar().clickSecurityButton();
|
|
await p2SecurityDialog.waitForDisplay();
|
|
|
|
await p2SecurityDialog.toggleLobby();
|
|
await p2SecurityDialog.waitForLobbyEnabled();
|
|
|
|
// here the important check is whether the moderator sees the knocking participant
|
|
await enterLobby(p2, false);
|
|
});
|
|
|
|
it('shared password', async () => {
|
|
await hangupAllParticipants();
|
|
|
|
await ensureTwoParticipants();
|
|
|
|
const { p1 } = ctx;
|
|
|
|
await enableLobby();
|
|
|
|
const p1SecurityDialog = p1.getSecurityDialog();
|
|
|
|
await p1.getToolbar().clickSecurityButton();
|
|
await p1SecurityDialog.waitForDisplay();
|
|
|
|
expect(await p1SecurityDialog.isLocked()).toBe(false);
|
|
|
|
const roomPasscode = String(Math.trunc(Math.random() * 1_000_000));
|
|
|
|
await p1SecurityDialog.addPassword(roomPasscode);
|
|
|
|
await p1.driver.waitUntil(
|
|
() => p1SecurityDialog.isLocked(),
|
|
{
|
|
timeout: 2000,
|
|
timeoutMsg: 'room did not lock for p1'
|
|
}
|
|
);
|
|
|
|
await enterLobby(p1, false);
|
|
|
|
const { p3 } = ctx;
|
|
|
|
// now fill in password
|
|
const lobbyScreen = p3.getLobbyScreen();
|
|
|
|
await lobbyScreen.enterPassword(roomPasscode);
|
|
|
|
await p3.waitToJoinMUC();
|
|
await p3.waitForIceConnected();
|
|
await p3.waitForSendReceiveData();
|
|
});
|
|
|
|
it('enable with more than two participants', async () => {
|
|
await hangupAllParticipants();
|
|
|
|
await ensureThreeParticipants();
|
|
|
|
await enableLobby();
|
|
|
|
// we need to check remote participants as isInMuc has not changed its value as
|
|
// the bug is triggered by presence with status 322 which is not handled correctly
|
|
const { p1, p2, p3 } = ctx;
|
|
|
|
await p1.waitForRemoteStreams(2);
|
|
await p2.waitForRemoteStreams(2);
|
|
await p3.waitForRemoteStreams(2);
|
|
});
|
|
|
|
it('moderator leaves while lobby enabled', async () => {
|
|
// no moderator switching if jaas is available.
|
|
if (config.iframe.usesJaas) {
|
|
return;
|
|
}
|
|
const { p1, p2, p3 } = ctx;
|
|
|
|
await p3.hangup();
|
|
await p1.hangup();
|
|
|
|
await p2.driver.waitUntil(
|
|
() => p2.isModerator(),
|
|
{
|
|
timeout: 3000,
|
|
timeoutMsg: 'p2 is not moderator after p1 leaves'
|
|
}
|
|
);
|
|
|
|
const lobbyScreen = p2.getLobbyScreen();
|
|
|
|
expect(await lobbyScreen.isLobbyRoomJoined()).toBe(true);
|
|
});
|
|
|
|
it('reject and approve in pre-join', async () => {
|
|
await hangupAllParticipants();
|
|
|
|
await ensureTwoParticipants();
|
|
await enableLobby();
|
|
|
|
const { p1 } = ctx;
|
|
|
|
const knockingParticipant = await enterLobby(p1, true, true);
|
|
|
|
// moderator rejects access
|
|
const p1ParticipantsPane = p1.getParticipantsPane();
|
|
|
|
await p1ParticipantsPane.open();
|
|
await p1ParticipantsPane.rejectLobbyParticipant(knockingParticipant);
|
|
await p1ParticipantsPane.close();
|
|
|
|
const { p3 } = ctx;
|
|
|
|
// check the denied one is out of lobby, sees the notification about it
|
|
// The third participant should see a warning that his access to the room was denied
|
|
await p3.getNotifications().waitForLobbyAccessDeniedNotification();
|
|
|
|
// check Lobby room left
|
|
expect(await p3.getLobbyScreen().isLobbyRoomJoined()).toBe(false);
|
|
|
|
// try again entering the lobby with the third one and approve it
|
|
// check that everything is fine in the meeting
|
|
await p3.getNotifications().closeLocalLobbyAccessDenied();
|
|
|
|
// let's retry to enter the lobby and approve this time
|
|
const lobbyScreen = p3.getPreJoinScreen();
|
|
|
|
// click join button
|
|
await lobbyScreen.getJoinButton().click();
|
|
await lobbyScreen.waitToJoinLobby();
|
|
|
|
// check that moderator (participant 1) sees notification about participant in lobby
|
|
const name = await p1.getNotifications().getKnockingParticipantName();
|
|
|
|
expect(name).toBe(P3);
|
|
expect(await lobbyScreen.isLobbyRoomJoined()).toBe(true);
|
|
|
|
await p1ParticipantsPane.open();
|
|
await p1ParticipantsPane.admitLobbyParticipant(knockingParticipant);
|
|
await p1ParticipantsPane.close();
|
|
|
|
await p3.waitForParticipants(2);
|
|
await p3.waitForRemoteStreams(2);
|
|
|
|
expect(await p3.getFilmstrip().countVisibleThumbnails()).toBe(3);
|
|
});
|
|
});
|
|
|
|
/**
|
|
* Enable lobby and check that it is enabled.
|
|
*/
|
|
async function enableLobby() {
|
|
const { p1, p2 } = ctx;
|
|
|
|
const p1SecurityDialog = p1.getSecurityDialog();
|
|
|
|
await p1.getToolbar().clickSecurityButton();
|
|
await p1SecurityDialog.waitForDisplay();
|
|
|
|
expect(await p1SecurityDialog.isLobbyEnabled()).toBe(false);
|
|
|
|
await p1SecurityDialog.toggleLobby();
|
|
await p1SecurityDialog.waitForLobbyEnabled();
|
|
|
|
expect((await p2.getNotifications().getLobbyEnabledText()).includes(p1.name)).toBe(true);
|
|
|
|
await p2.getNotifications().closeLobbyEnabled();
|
|
|
|
const p2SecurityDialog = p2.getSecurityDialog();
|
|
|
|
await p2.getToolbar().clickSecurityButton();
|
|
await p2SecurityDialog.waitForDisplay();
|
|
|
|
// lobby is visible to moderators only, this depends on whether deployment is all moderators or not
|
|
if (await p2.isModerator()) {
|
|
await p2SecurityDialog.waitForLobbyEnabled();
|
|
} else {
|
|
expect(await p2SecurityDialog.isLobbySectionPresent()).toBe(false);
|
|
}
|
|
|
|
// let's close the security dialog, or we will not be able to click
|
|
// on popups for allow/deny participants
|
|
await p1SecurityDialog.clickCloseButton();
|
|
await p2SecurityDialog.clickCloseButton();
|
|
}
|
|
|
|
/**
|
|
* Expects that lobby is enabled for the room we will try to join.
|
|
* Lobby UI is shown, enter display name and join.
|
|
* Checks Lobby UI and also that when joining the moderator sees corresponding notifications.
|
|
*
|
|
* @param participant The participant that is moderator in the meeting.
|
|
* @param enterDisplayName whether to enter display name. We need to enter display name only the first time when
|
|
* a participant sees the lobby screen, next time visiting the page display name will be pre-filled
|
|
* from local storage.
|
|
* @param usePreJoin
|
|
* @return the participant name knocking.
|
|
*/
|
|
async function enterLobby(participant: Participant, enterDisplayName = false, usePreJoin = false) {
|
|
const options: IJoinOptions = { };
|
|
|
|
if (usePreJoin) {
|
|
options.configOverwrite = {
|
|
prejoinConfig: {
|
|
enabled: true
|
|
}
|
|
};
|
|
}
|
|
|
|
await ensureThreeParticipants({
|
|
...options,
|
|
skipDisplayName: true,
|
|
skipWaitToJoin: true,
|
|
skipInMeetingChecks: true
|
|
});
|
|
|
|
const { p3 } = ctx;
|
|
let screen: PreMeetingScreen;
|
|
|
|
// WebParticipant participant3 = getParticipant3();
|
|
// ParentPreMeetingScreen lobbyScreen;
|
|
if (usePreJoin) {
|
|
screen = p3.getPreJoinScreen();
|
|
} else {
|
|
screen = p3.getLobbyScreen();
|
|
}
|
|
|
|
// participant 3 should be now on pre-join screen
|
|
await screen.waitForLoading();
|
|
|
|
const displayNameInput = screen.getDisplayNameInput();
|
|
|
|
// check display name is visible
|
|
expect(await displayNameInput.isExisting()).toBe(true);
|
|
expect(await displayNameInput.isDisplayed()).toBe(true);
|
|
|
|
const joinButton = screen.getJoinButton();
|
|
|
|
expect(await joinButton.isExisting()).toBe(true);
|
|
|
|
if (enterDisplayName) {
|
|
let classes = await joinButton.getAttribute('class');
|
|
|
|
if (!usePreJoin) {
|
|
// check join button is disabled
|
|
expect(classes.includes('disabled')).toBe(true);
|
|
}
|
|
|
|
// TODO check that password is hidden as the room does not have password
|
|
// this check needs to be added once the functionality exists
|
|
|
|
// enter display name
|
|
await screen.enterDisplayName(P3);
|
|
|
|
// check join button is enabled
|
|
classes = await joinButton.getAttribute('class');
|
|
expect(classes.includes('disabled')).toBe(false);
|
|
}
|
|
|
|
// click join button
|
|
await screen.getJoinButton().click();
|
|
await screen.waitToJoinLobby();
|
|
|
|
// check no join button
|
|
await p3.driver.waitUntil(
|
|
async () => !await joinButton.isExisting() || !await joinButton.isDisplayed() || !await joinButton.isEnabled(),
|
|
{
|
|
timeout: 2_000,
|
|
timeoutMsg: 'Join button is still available for p3'
|
|
});
|
|
|
|
// new screen, is password button shown
|
|
const passwordButton = screen.getPasswordButton();
|
|
|
|
expect(await passwordButton.isExisting()).toBe(true);
|
|
expect(await passwordButton.isEnabled()).toBe(true);
|
|
|
|
// check that moderator (participant 1) sees notification about participant in lobby
|
|
const name = await participant.getNotifications().getKnockingParticipantName();
|
|
|
|
expect(name).toBe(P3);
|
|
expect(await screen.isLobbyRoomJoined()).toBe(true);
|
|
|
|
return name;
|
|
}
|