Update main-fr.json

Uses the end_meeting endpoint to trigger a silent reconnect by destroying the current conference and passing its jid.

lang/main-fr.json

@@ -120,7 +120,7 @@
         "messageAccessibleTitle": "{{user}} dit: ",
         "messageAccessibleTitleMe": "Je dis: ",
         "messageTo": "Message privé à {{recipient}}",
-        "messagebox": "Saisissez un message",
+        "messagebox": "Envoyer un message",
         "newMessages": "Nouveaux messages",
         "nickname": {
             "popover": "Choisissez un pseudonyme",

lang/main.json

@@ -570,10 +570,12 @@
         "downloadStarted": "File download started",
         "dragAndDrop": "Drag and drop files here or anywhere on screen",
         "fileAlreadyUploaded": "File has already been uploaded to this meeting.",
+        "fileRemovedByOther": "Your file '{{ fileName }}' was removed",
         "fileTooLargeDescription": "Please make sure the file does not exceed {{ maxFileSize }}.",
         "fileTooLargeTitle": "The selected file is too large",
         "fileUploadProgress": "File upload progress",
         "fileUploadedSuccessfully": "File uploaded successfully",
+        "newFileNotification": "{{ participantName }} shared '{{ fileName }}'",
         "removeFile": "Remove",
         "removeFileSuccess": "File removed successfully",
         "uploadFailedDescription": "Please try again.",

react/features/base/conference/functions.ts

@@ -7,6 +7,8 @@ import { showNotification } from '../../notifications/actions';
 import { NOTIFICATION_TIMEOUT_TYPE } from '../../notifications/constants';
 import { determineTranscriptionLanguage } from '../../transcribing/functions';
 import { IStateful } from '../app/types';
+import { connect } from '../connection/actions';
+import { disconnect } from '../connection/actions.any';
 import { JitsiTrackErrors } from '../lib-jitsi-meet';
 import { setAudioMuted, setVideoMuted } from '../media/actions';
 import { VIDEO_MUTISM_AUTHORITY } from '../media/constants';
@@ -22,7 +24,7 @@ import {
     safeDecodeURIComponent
 } from '../util/uri';
 
-import { setObfuscatedRoom } from './actions';
+import { conferenceWillInit, setObfuscatedRoom } from './actions';
 import {
     AVATAR_URL_COMMAND,
     EMAIL_COMMAND,
@@ -618,3 +620,34 @@ export function updateTrackMuteState(stateful: IStateful, dispatch: IStore['disp
         }, NOTIFICATION_TIMEOUT_TYPE.SHORT));
     }
 }
+
+/**
+ * Processes the "destroyed" event of a conference and if the destroyed conference is the current one,
+ * it silently reconnects to the same room.
+ *
+ * @param {Object|Function} stateful - Either the whole Redux state object or the Redux store's {@code getState} method.
+ * @param {Function} dispatch - Redux dispatch function.
+ * @param {Array} params - The parameters for the destroy event.
+ *
+ * @returns {boolean} - True if the destroyed conference was the current one, and we are reconnecting, false otherwise.
+ */
+export function processDestroyConferenceEvent(stateful: IStateful, dispatch: IStore['dispatch'], params: Array<any>) {
+    const [ jid ] = params;
+    const conference = getCurrentConference(stateful);
+
+    // if the jid of the room is the same as the current conference, we are being
+    // notified that the current conference has been destroyed, and we need to reconnect
+    if (conference?.room?.roomjid === jid) {
+        dispatch(disconnect(true, false))
+            .then(() => {
+                dispatch(conferenceWillInit());
+                logger.info('Dispatching silent re-connect.');
+
+                return dispatch(connect());
+            });
+
+        return true;
+    }
+
+    return false;
+}

react/features/base/conference/middleware.native.ts

@@ -6,8 +6,8 @@ import MiddlewareRegistry from '../redux/MiddlewareRegistry';
 import { CONFERENCE_FAILED } from './actionTypes';
 import { conferenceLeft } from './actions.native';
 import { TRIGGER_READY_TO_CLOSE_REASONS } from './constants';
-
 import './middleware.any';
+import { processDestroyConferenceEvent } from './functions';
 
 MiddlewareRegistry.register(store => next => action => {
     const { dispatch } = store;
@@ -23,6 +23,10 @@ MiddlewareRegistry.register(store => next => action => {
             break;
         }
 
+        if (processDestroyConferenceEvent(state, dispatch, error.params)) {
+            break;
+        }
+
         if (!notifyOnConferenceDestruction) {
             dispatch(conferenceLeft(action.conference));
             dispatch(appNavigate(undefined));

react/features/base/conference/middleware.web.ts

@@ -24,8 +24,8 @@ import {
     KICKED_OUT
 } from './actionTypes';
 import { TRIGGER_READY_TO_CLOSE_REASONS } from './constants';
+import { processDestroyConferenceEvent } from './functions';
 import logger from './logger';
-
 import './middleware.any';
 
 let screenLock: WakeLockSentinel | undefined;
@@ -127,6 +127,11 @@ MiddlewareRegistry.register(store => next => action => {
             const state = getState();
             const { notifyOnConferenceDestruction = true } = state['features/base/config'];
             const [ reason ] = action.error.params;
+
+            if (processDestroyConferenceEvent(state, dispatch, action.error.params)) {
+                break;
+            }
+
             const titlekey = Object.keys(TRIGGER_READY_TO_CLOSE_REASONS)[
                 Object.values(TRIGGER_READY_TO_CLOSE_REASONS).indexOf(reason)
             ];

react/features/base/connection/actions.any.ts

@@ -385,10 +385,10 @@ function _propertiesUpdate(properties: object) {
  * Closes connection.
  *
  * @param {boolean} isRedirect - Indicates if the action has been dispatched as part of visitor promotion.
- *
+ * @param {boolean} shouldLeave - Indicates whether to call JitsiConference.leave().
  * @returns {Function}
  */
-export function disconnect(isRedirect?: boolean) {
+export function disconnect(isRedirect?: boolean, shouldLeave = true) {
     return (dispatch: IStore['dispatch'], getState: IStore['getState']): Promise<void> => {
         const state = getState();
 
@@ -407,20 +407,26 @@ export function disconnect(isRedirect?: boolean) {
             // intention to leave the conference.
             dispatch(conferenceWillLeave(conference_, isRedirect));
 
-            promise
-                = conference_.leave()
-                .catch((error: Error) => {
-                    logger.warn(
-                        'JitsiConference.leave() rejected with:',
-                        error);
+            if (!shouldLeave) {
+                // we are skipping JitsiConference.leave(), but will still dispatch the normal leave flow events
+                dispatch(conferenceLeft(conference_));
+                promise = Promise.resolve();
+            } else {
+                promise
+                    = conference_.leave()
+                    .catch((error: Error) => {
+                        logger.warn(
+                            'JitsiConference.leave() rejected with:',
+                            error);
 
-                    // The library lib-jitsi-meet failed to make the
-                    // JitsiConference leave. Which may be because
-                    // JitsiConference thinks it has already left.
-                    // Regardless of the failure reason, continue in
-                    // jitsi-meet as if the leave has succeeded.
-                    dispatch(conferenceLeft(conference_));
-                });
+                        // The library lib-jitsi-meet failed to make the
+                        // JitsiConference leave. Which may be because
+                        // JitsiConference thinks it has already left.
+                        // Regardless of the failure reason, continue in
+                        // jitsi-meet as if the leave has succeeded.
+                        dispatch(conferenceLeft(conference_));
+                    });
+            }
         } else {
             promise = Promise.resolve();
         }

react/features/chat/components/native/Chat.tsx

@@ -7,7 +7,9 @@ import { IReduxState } from '../../../app/types';
 import { translate } from '../../../base/i18n/functions';
 import JitsiScreen from '../../../base/modal/components/JitsiScreen';
 import { TabBarLabelCounter } from '../../../mobile/navigation/components/TabBarLabelCounter';
+import { getUnreadPollCount } from '../../../polls/functions';
 import { closeChat, sendMessage } from '../../actions.native';
+import { getUnreadFilesCount } from '../../functions';
 import { IChatProps as AbstractProps } from '../../types';
 
 import ChatInputBar from './ChatInputBar';
@@ -17,6 +19,21 @@ import styles from './styles';
 
 interface IProps extends AbstractProps {
 
+    /**
+     * The number of unread file messages.
+     */
+    _nbUnreadFiles: number;
+
+    /**
+     * The number of unread messages.
+     */
+    _nbUnreadMessages: number;
+
+    /**
+     * The number of unread polls.
+     */
+    _nbUnreadPolls: number;
+
     /**
      * Default prop for navigating between screen components(React Navigation).
      */
@@ -96,7 +113,9 @@ class Chat extends Component<IProps> {
  * @private
  * @returns {{
  *     _messages: Array<Object>,
- *     _nbUnreadMessages: number
+ *     _nbUnreadMessages: number,
+ *     _nbUnreadPolls: number,
+ *     _nbUnreadFiles: number
  * }}
  */
 function _mapStateToProps(state: IReduxState, _ownProps: any) {
@@ -104,13 +123,16 @@ function _mapStateToProps(state: IReduxState, _ownProps: any) {
 
     return {
         _messages: messages,
-        _nbUnreadMessages: nbUnreadMessages
+        _nbUnreadMessages: nbUnreadMessages,
+        _nbUnreadPolls: getUnreadPollCount(state),
+        _nbUnreadFiles: getUnreadFilesCount(state)
     };
 }
 
 export default translate(connect(_mapStateToProps)((props: IProps) => {
-    const { _nbUnreadMessages, dispatch, navigation, t } = props;
-    const unreadMessagesNr = _nbUnreadMessages > 0;
+    const { _nbUnreadMessages, _nbUnreadPolls, _nbUnreadFiles, dispatch, navigation, t } = props;
+    const totalUnread = _nbUnreadMessages + _nbUnreadPolls + _nbUnreadFiles;
+    const unreadMessagesNr = totalUnread > 0;
 
     const isFocused = useIsFocused();
 
@@ -121,14 +143,14 @@ export default translate(connect(_mapStateToProps)((props: IProps) => {
                     activeUnreadNr = { unreadMessagesNr }
                     isFocused = { isFocused }
                     label = { t('chat.tabs.chat') }
-                    nbUnread = { _nbUnreadMessages } />
+                    nbUnread = { totalUnread } />
             )
         });
 
         return () => {
             isFocused && dispatch(closeChat());
         };
-    }, [ isFocused, _nbUnreadMessages ]);
+    }, [ isFocused, _nbUnreadMessages, _nbUnreadPolls, _nbUnreadFiles ]);
 
     return (
         <Chat { ...props } />

react/features/chat/components/native/ChatButton.ts

@@ -10,7 +10,7 @@ import { arePollsDisabled } from '../../../conference/functions.any';
 import { navigate } from '../../../mobile/navigation/components/conference/ConferenceNavigationContainerRef';
 import { screen } from '../../../mobile/navigation/routes';
 import { getUnreadPollCount } from '../../../polls/functions';
-import { getUnreadCount } from '../../functions';
+import { getUnreadCount, getUnreadFilesCount } from '../../functions';
 
 interface IProps extends AbstractButtonProps {
 
@@ -70,9 +70,7 @@ function _mapStateToProps(state: IReduxState, ownProps: any) {
 
     return {
         _isPollsDisabled: arePollsDisabled(state),
-
-        // The toggled icon should also be available for new polls
-        _unreadMessageCount: getUnreadCount(state) || getUnreadPollCount(state),
+        _unreadMessageCount: getUnreadCount(state) || getUnreadPollCount(state) || getUnreadFilesCount(state),
         visible
     };
 }

react/features/chat/components/web/Chat.tsx

@@ -73,6 +73,11 @@ interface IProps extends AbstractProps {
      */
     _isResizing: boolean;
 
+    /**
+     * Number of unread file sharing messages.
+     */
+    _nbUnreadFiles: number;
+
     /**
      * Number of unread poll messages.
      */
@@ -218,6 +223,7 @@ const Chat = ({
     _messages,
     _nbUnreadMessages,
     _nbUnreadPolls,
+    _nbUnreadFiles,
     _showNamePrompt,
     _width,
     dispatch,
@@ -512,7 +518,7 @@ const Chat = ({
         if (_isFileSharingTabEnabled) {
             tabs.push({
                 accessibilityLabel: t('chat.tabs.fileSharing'),
-                countBadge: undefined,
+                countBadge: _focusedTab !== ChatTabs.FILE_SHARING && _nbUnreadFiles > 0 ? _nbUnreadFiles : undefined,
                 id: ChatTabs.FILE_SHARING,
                 controlsId: `${ChatTabs.FILE_SHARING}-panel`,
                 icon: IconShareDoc,
@@ -586,13 +592,14 @@ const Chat = ({
  *     _messages: Array<Object>,
  *     _nbUnreadMessages: number,
  *     _nbUnreadPolls: number,
+ *     _nbUnreadFiles: number,
  *     _showNamePrompt: boolean,
  *     _width: number,
  *     _isResizing: boolean
  * }}
  */
 function _mapStateToProps(state: IReduxState, _ownProps: any) {
-    const { isOpen, focusedTab, messages, nbUnreadMessages, width, isResizing } = state['features/chat'];
+    const { isOpen, focusedTab, messages, nbUnreadMessages, nbUnreadFiles, width, isResizing } = state['features/chat'];
     const { nbUnreadPolls } = state['features/polls'];
     const _localParticipant = getLocalParticipant(state);
 
@@ -606,6 +613,7 @@ function _mapStateToProps(state: IReduxState, _ownProps: any) {
         _messages: messages,
         _nbUnreadMessages: nbUnreadMessages,
         _nbUnreadPolls: nbUnreadPolls,
+        _nbUnreadFiles: nbUnreadFiles,
         _showNamePrompt: !_localParticipant?.name,
         _width: width?.current || CHAT_SIZE,
         _isResizing: isResizing

react/features/chat/components/web/ChatCounter.tsx

@@ -3,7 +3,7 @@ import { connect } from 'react-redux';
 
 import { IReduxState } from '../../../app/types';
 import { getUnreadPollCount } from '../../../polls/functions';
-import { getUnreadCount } from '../../functions';
+import { getUnreadCount, getUnreadFilesCount } from '../../functions';
 
 /**
  * The type of the React {@code Component} props of {@link ChatCounter}.
@@ -65,7 +65,7 @@ function _mapStateToProps(state: IReduxState) {
 
     return {
 
-        _count: getUnreadCount(state) + getUnreadPollCount(state),
+        _count: getUnreadCount(state) + getUnreadPollCount(state) + getUnreadFilesCount(state),
         _isOpen: isOpen
 
     };

react/features/chat/functions.ts

@@ -131,6 +131,16 @@ export function getUnreadCount(state: IReduxState) {
     return messagesCount - (lastReadIndex + 1) - reactionMessages;
 }
 
+/**
+ * Gets the unread files count.
+ *
+ * @param {IReduxState} state - The redux state.
+ * @returns {number} The number of unread files.
+ */
+export function getUnreadFilesCount(state: IReduxState): number {
+    return state['features/chat']?.nbUnreadFiles || 0;
+}
+
 /**
  * Get whether the chat smileys are disabled or not.
  *

react/features/chat/reducer.ts

@@ -1,6 +1,7 @@
 import { UPDATE_CONFERENCE_METADATA } from '../base/conference/actionTypes';
 import { ILocalParticipant, IParticipant } from '../base/participants/types';
 import ReducerRegistry from '../base/redux/ReducerRegistry';
+import { ADD_FILE, _FILE_LIST_RECEIVED } from '../file-sharing/actionTypes';
 import { IVisitorChatParticipant } from '../visitors/types';
 
 import {
@@ -30,6 +31,7 @@ const DEFAULT_STATE = {
     notifyPrivateRecipientsChangedTimestamp: undefined,
     reactions: {},
     nbUnreadMessages: 0,
+    nbUnreadFiles: 0,
     privateMessageRecipient: undefined,
     lobbyMessageRecipient: undefined,
     isLobbyChatActive: false,
@@ -53,6 +55,7 @@ export interface IChatState {
         name: string;
     } | ILocalParticipant;
     messages: IMessage[];
+    nbUnreadFiles: number;
     nbUnreadMessages: number;
     notifyPrivateRecipientsChangedTimestamp?: number;
     privateMessageRecipient?: IParticipant | IVisitorChatParticipant;
@@ -235,7 +238,8 @@ ReducerRegistry.register<IChatState>('features/chat', (state = DEFAULT_STATE, ac
         return {
             ...state,
             focusedTab: action.tabId,
-            nbUnreadMessages: action.tabId === ChatTabs.CHAT ? 0 : state.nbUnreadMessages
+            nbUnreadMessages: action.tabId === ChatTabs.CHAT ? 0 : state.nbUnreadMessages,
+            nbUnreadFiles: action.tabId === ChatTabs.FILE_SHARING ? 0 : state.nbUnreadFiles
         };
 
     case SET_CHAT_WIDTH: {
@@ -271,6 +275,23 @@ ReducerRegistry.register<IChatState>('features/chat', (state = DEFAULT_STATE, ac
             ...state,
             notifyPrivateRecipientsChangedTimestamp: action.payload
         };
+
+    case ADD_FILE:
+        return {
+            ...state,
+            nbUnreadFiles: action.shouldIncrementUnread ? state.nbUnreadFiles + 1 : state.nbUnreadFiles
+        };
+
+    case _FILE_LIST_RECEIVED: {
+        const remoteFilesCount = Object.values(action.files).filter(
+            (file: any) => file.authorParticipantId !== action.localParticipantId
+        ).length;
+
+        return {
+            ...state,
+            nbUnreadFiles: remoteFilesCount
+        };
+    }
     }
 
     return state;

react/features/file-sharing/actions.ts

@@ -39,12 +39,14 @@ export function updateFileProgress(fileId: string, progress: number) {
  * Add a file.
  *
  * @param {IFileMetadata} file - The file to add to the state.
+ * @param {boolean} shouldIncrementUnread - Whether to increment the unread count.
  * @returns {Object}
  */
-export function addFile(file: IFileMetadata) {
+export function addFile(file: IFileMetadata, shouldIncrementUnread = false) {
     return {
         type: ADD_FILE,
-        file
+        file,
+        shouldIncrementUnread
     };
 }
 

react/features/file-sharing/middleware.web.ts

@@ -6,8 +6,10 @@ import { JitsiConferenceEvents } from '../base/lib-jitsi-meet';
 import { getLocalParticipant, getParticipantDisplayName } from '../base/participants/functions';
 import MiddlewareRegistry from '../base/redux/MiddlewareRegistry';
 import StateListenerRegistry from '../base/redux/StateListenerRegistry';
+import { ChatTabs } from '../chat/constants';
 import { showErrorNotification, showNotification, showSuccessNotification } from '../notifications/actions';
 import { NOTIFICATION_TIMEOUT_TYPE, NOTIFICATION_TYPE } from '../notifications/constants';
+import { I_AM_VISITOR_MODE } from '../visitors/actionTypes';
 
 import { DOWNLOAD_FILE, REMOVE_FILE, UPLOAD_FILES, _FILE_LIST_RECEIVED, _FILE_REMOVED } from './actionTypes';
 import { addFile, removeFile, updateFileProgress } from './actions';
@@ -23,12 +25,40 @@ import { downloadFile } from './utils';
  */
 StateListenerRegistry.register(
     state => state['features/base/conference'].conference,
-    (conference, { dispatch }, previousConference) => {
+    (conference, { dispatch, getState }, previousConference) => {
         if (conference && !previousConference) {
             conference.on(JitsiConferenceEvents.FILE_SHARING_FILE_ADDED, (file: IFileMetadata) => {
-                dispatch(addFile(file));
+                const state = getState();
+                const localParticipant = getLocalParticipant(state);
+                const isRemoteFile = file.authorParticipantId !== localParticipant?.id;
+                const { isOpen, focusedTab } = state['features/chat'];
+                const isFileSharingTabVisible = isOpen && focusedTab === ChatTabs.FILE_SHARING;
+
+                dispatch(addFile(file, isRemoteFile && !isFileSharingTabVisible));
+
+                if (isRemoteFile && !isFileSharingTabVisible) {
+                    dispatch(showNotification({
+                        titleKey: 'fileSharing.newFileNotification',
+                        titleArguments: { participantName: file.authorParticipantName, fileName: file.fileName }
+                    }, NOTIFICATION_TIMEOUT_TYPE.SHORT));
+                }
             });
             conference.on(JitsiConferenceEvents.FILE_SHARING_FILE_REMOVED, (fileId: string) => {
+                const state = getState();
+                const localParticipant = getLocalParticipant(state);
+                const { files } = state['features/file-sharing'];
+                const { isOpen, focusedTab } = state['features/chat'];
+                const removedFile = files.get(fileId);
+                const isFileSharingTabVisible = isOpen && focusedTab === ChatTabs.FILE_SHARING;
+
+                if (removedFile && removedFile.authorParticipantId === localParticipant?.id && !isFileSharingTabVisible) {
+                    dispatch(showNotification({
+                        titleKey: 'fileSharing.fileRemovedByOther',
+                        titleArguments: { fileName: removedFile.fileName },
+                        appearance: NOTIFICATION_TYPE.WARNING
+                    }, NOTIFICATION_TIMEOUT_TYPE.MEDIUM));
+                }
+
                 dispatch({
                     type: _FILE_REMOVED,
                     fileId
@@ -36,9 +66,13 @@ StateListenerRegistry.register(
             });
 
             conference.on(JitsiConferenceEvents.FILE_SHARING_FILES_RECEIVED, (files: object) => {
+                const state = getState();
+                const localParticipant = getLocalParticipant(state);
+
                 dispatch({
                     type: _FILE_LIST_RECEIVED,
-                    files
+                    files,
+                    localParticipantId: localParticipant?.id
                 });
             });
         }
@@ -52,6 +86,17 @@ StateListenerRegistry.register(
  */
 MiddlewareRegistry.register(store => next => action => {
     switch (action.type) {
+    case I_AM_VISITOR_MODE: {
+        if (!action.iAmVisitor) {
+            const state = store.getState();
+            const conference = getCurrentConference(state);
+
+            conference?.getFileSharing()?.requestFileList?.();
+        }
+
+        return next(action);
+    }
+
     case UPLOAD_FILES: {
         const state = store.getState();
         const conference = getCurrentConference(state);

react/features/file-sharing/reducer.ts

@@ -1,6 +1,11 @@
 import ReducerRegistry from '../base/redux/ReducerRegistry';
 
-import { ADD_FILE, UPDATE_FILE_UPLOAD_PROGRESS, _FILE_LIST_RECEIVED, _FILE_REMOVED } from './actionTypes';
+import {
+    ADD_FILE,
+    UPDATE_FILE_UPLOAD_PROGRESS,
+    _FILE_LIST_RECEIVED,
+    _FILE_REMOVED
+} from './actionTypes';
 import { IFileMetadata } from './types';
 
 export interface IFileSharingState {
@@ -20,6 +25,7 @@ ReducerRegistry.register<IFileSharingState>('features/file-sharing',
         newFiles.set(action.file.fileId, action.file);
 
         return {
+            ...state,
             files: newFiles
         };
     }
@@ -30,6 +36,7 @@ ReducerRegistry.register<IFileSharingState>('features/file-sharing',
         newFiles.delete(action.fileId);
 
         return {
+            ...state,
             files: newFiles
         };
     }
@@ -43,12 +50,14 @@ ReducerRegistry.register<IFileSharingState>('features/file-sharing',
         }
 
         return {
+            ...state,
             files: newFiles
         };
     }
 
     case _FILE_LIST_RECEIVED: {
         return {
+            ...state,
             files: new Map(Object.entries(action.files))
         };
     }

resources/prosody-plugins/mod_muc_end_meeting.lua

@@ -6,6 +6,7 @@ module:set_global();
 
 local util = module:require "util";
 local async_handler_wrapper = util.async_handler_wrapper;
+local internal_room_jid_match_rewrite = util.internal_room_jid_match_rewrite;
 local room_jid_match_rewrite = util.room_jid_match_rewrite;
 local get_room_from_jid = util.get_room_from_jid;
 local starts_with = util.starts_with;
@@ -17,6 +18,8 @@ local parse = neturl.parseQuery;
 local token_util;
 
 local muc_domain_base = module:get_option_string("muc_mapper_domain_base");
+local muc_domain_prefix = module:get_option_string('muc_mapper_domain_prefix', 'conference');
+local muc_domain = muc_domain_prefix..'.'..muc_domain_base;
 
 local asapKeyServer = module:get_option_string("prosody_password_public_key_repo_url", "");
 
@@ -47,6 +50,7 @@ function handle_terminate_meeting (event)
     end
     local params = parse(event.request.url.query);
     local conference = params["conference"];
+    local silent_reconnect = params['silent-reconnect'];
     local room_jid;
 
     if conference then
@@ -78,8 +82,13 @@ function handle_terminate_meeting (event)
         module:log("warn", "Room not found")
         return { status_code = 404 };
     else
-        module:log("info", "Destroy room jid %s", room.jid)
-        room:destroy(nil, "The meeting has been terminated")
+        if silent_reconnect == 'true' then
+            module:log('info', 'Setting silent_reconnect on room %s', room.jid);
+            room:destroy(internal_room_jid_match_rewrite(room.jid), 'The meeting has been terminated silently')
+        else
+            module:log("info", "Destroy room jid %s", room.jid)
+            room:destroy(nil, "The meeting has been terminated")
+        end
     end
     event_count_success()
     return { status_code = 200 };

resources/prosody-plugins/mod_muc_lobby_rooms.lua

@@ -48,6 +48,7 @@ local NOTIFY_LOBBY_ACCESS_DENIED = 'LOBBY-ACCESS-DENIED';
 local util = module:require "util";
 local ends_with = util.ends_with;
 local get_room_by_name_and_subdomain = util.get_room_by_name_and_subdomain;
+local get_room_from_jid = util.get_room_from_jid;
 local is_healthcheck_room = util.is_healthcheck_room;
 local presence_check_status = util.presence_check_status;
 local process_host_module = util.process_host_module;
@@ -105,7 +106,7 @@ end
 
 -- Sends a json message notifying that the jid was granted/denied access in lobby
 -- the message from is the actor that did the operation
-function notify_lobby_access(room, actor, jid, display_name, granted)
+function notify_lobby_access(room_jid, actor, jid, display_name, granted)
     local notify_json = {
         value = jid,
         name = display_name
@@ -116,6 +117,12 @@ function notify_lobby_access(room, actor, jid, display_name, granted)
         notify_json.event = NOTIFY_LOBBY_ACCESS_DENIED;
     end
 
+    local room = get_room_from_jid(room_jid);
+    if not room then
+        module:log('error', 'Room not found for %s', room_jid)
+        return;
+    end
+
     broadcast_json_msg(room, actor, notify_json);
 end
 
@@ -227,7 +234,7 @@ function attach_lobby_room(room, actor)
         -- avoid lobby destroy while it is enabled
         new_room:set_persistent(true);
         module:log("info","Lobby room jid = %s created from:%s", lobby_room_jid, actor);
-        new_room.main_room = room;
+        new_room.main_room_jid = room.jid;
         room._data.lobbyroom = new_room.jid;
         room:save(true);
         return true
@@ -245,6 +252,8 @@ function destroy_lobby_room(room, newjid, message)
         if lobby_room_obj then
             lobby_room_obj:set_persistent(false);
             lobby_room_obj:destroy(newjid, message);
+
+            module:log('info', 'Lobby room destroyed %s', lobby_room_obj.jid)
         end
         room._data.lobbyroom = nil;
         room._data.lobby_extra_reason = nil;
@@ -412,13 +421,18 @@ function process_lobby_muc_loaded(lobby_muc, host_module)
     local room_mt = lobby_muc_service.room_mt;
     -- we base affiliations (roles) in lobby muc component to be based on the roles in the main muc
     room_mt.get_affiliation = function(room, jid)
-        if not room.main_room then
+        if not room.main_room_jid then
             module:log('error', 'No main room(%s) for %s!', room.jid, jid);
             return 'none';
         end
 
         -- moderators in main room are moderators here
-        local role = room.main_room.get_affiliation(room.main_room, jid);
+        local main_room = get_room_from_jid(room.main_room_jid);
+        if not main_room then
+            module:log('error', 'Main room not found for %s!', room.main_room_jid);
+            return 'none';
+        end
+        local role = main_room.get_affiliation(main_room, jid);
         if role then
             return role;
         end
@@ -433,7 +447,7 @@ function process_lobby_muc_loaded(lobby_muc, host_module)
             local display_name = occupant:get_presence():get_child_text(
                 'nick', 'http://jabber.org/protocol/nick');
             -- we need to notify in the main room
-            notify_lobby_access(room.main_room, actor, occupant.nick, display_name, false);
+            notify_lobby_access(room.main_room_jid, actor, occupant.nick, display_name, false);
         end
     end);
 end
@@ -589,7 +603,7 @@ process_host_module(main_muc_component_config, function(host_module, host)
                     local display_name = occupant:get_presence():get_child_text(
                             'nick', 'http://jabber.org/protocol/nick');
 
-                    notify_lobby_access(room, from, occupant.nick, display_name, true);
+                    notify_lobby_access(room.jid, from, occupant.nick, display_name, true);
                 end
             end
         end

resources/prosody-plugins/mod_muc_rate_limit.lua

@@ -108,7 +108,13 @@ module:hook("muc-occupant-pre-join", function (event)
 
         if not room.join_rate_queue_timer then
             timer.add_task(1, function ()
-                local status, result = pcall(timer_process_queue_elements,
+                if room.destroying then
+                    -- if room was destroyed in the mean time, ignore
+                    return;
+                end
+
+                local status, result = pcall(
+                    timer_process_queue_elements,
                     join_rate_per_conference,
                     room.join_rate_presence_queue,
                     function(ev)

tests/helpers/TestsConfig.ts

@@ -4,18 +4,7 @@
 export const config = {
     /** Enable debug logging. Note this includes private information from .env */
     debug: Boolean(process.env.JITSI_DEBUG?.trim()),
-    /** Whether to expect the environment to automatically elect a new moderator when the existing moderator leaves. */
-    autoModerator: (() => {
-        if (typeof process.env.AUTO_MODERATOR !== 'undefined') {
-            return process.env.AUTO_MODERATOR?.trim() === 'true';
-        }
-
-        // If not explicitly configured, fallback to recognizing whether we're running against one of the JaaS
-        // environments which are known to have the setting disabled.
-        return !Boolean(
-            process.env.JWT_PRIVATE_KEY_PATH && process.env.JWT_KID?.startsWith('vpaas-magic-cookie-')
-        );
-    })(),
+    expectationsFile: process.env.EXPECTATIONS?.trim(),
     jaas: {
         customerId: (() => {
             if (typeof process.env.JAAS_TENANT !== 'undefined') {

tests/helpers/expectations.ts

@@ -0,0 +1,50 @@
+import fs from 'fs';
+import { merge } from 'lodash-es';
+
+import { config } from './TestsConfig';
+
+const defaultExpectations = {
+    dialIn: {
+        /*
+         * The dial-in functionality is enabled.
+         * true -> assert the config is enabled, the UI elements are displayed, and the feature works.
+         * false -> assert the config is disabled and the UI elements are not displayed.
+         * null -> if the config is enabled, assert the UI elements are displayed and the feature works.
+         */
+        enabled: null,
+    },
+    jaas: {
+        /**
+         * Whether the jaas account is configured with the account-level setting to allow unauthenticated users to join.
+         */
+        unauthenticatedJoins: false
+    },
+    moderation: {
+        // Everyone is a moderator.
+        allModerators: false,
+        // When a moderator leaves, another one is elected.
+        autoModerator: true,
+        // The first to join is a moderator.
+        firstModerator: true,
+        // The grantOwner function is available.
+        grantModerator: true
+    }
+};
+
+let overrides: any = {};
+
+if (config.expectationsFile) {
+    try {
+        const str = fs.readFileSync(config.expectationsFile, 'utf8');
+
+        // Remove comments and multiline comments.
+        overrides = JSON.parse(str.replace(/\/\/.*|\/\*[\s\S]*?\*\//g, ''));
+    } catch (e) {
+        console.error('Error reading expectations file', e);
+    }
+    console.log('Loaded expectations from', config.expectationsFile);
+}
+
+export const expectations = merge(defaultExpectations, overrides);
+
+console.log('Expectations:', expectations);

tests/specs/2way/fakeDialInAudio.spec.ts

@@ -1,5 +1,6 @@
 import process from 'node:process';
 
+import { expectations } from '../../helpers/expectations';
 import { ensureOneParticipant, ensureTwoParticipants } from '../../helpers/participants';
 import { cleanup, isDialInEnabled, waitForAudioFromDialInParticipant } from '../helpers/DialIn';
 
@@ -16,8 +17,15 @@ describe('Fake Dial-In', () => {
 
         await ensureOneParticipant();
 
+        const configEnabled = await isDialInEnabled(ctx.p1);
+
+        if (expectations.dialIn.enabled !== null) {
+            expect(configEnabled).toBe(expectations.dialIn.enabled);
+        }
+
         // check dial-in is enabled, so skip
-        if (await isDialInEnabled(ctx.p1)) {
+        if (configEnabled) {
+            console.log('Dial in config is enabled, skipping fake dial in');
             ctx.skipSuiteTests = true;
         }
     });

tests/specs/2way/grantModerator.spec.ts

@@ -1,42 +0,0 @@
-import { ensureOneParticipant, ensureTwoParticipants } from '../../helpers/participants';
-
-describe('Grant moderator', () => {
-    it('joining the meeting', async () => {
-        await ensureOneParticipant();
-
-        if (await ctx.p1.execute(() => typeof APP.conference._room.grantOwner !== 'function')) {
-            ctx.skipSuiteTests = true;
-
-            return;
-        }
-
-        await ensureTwoParticipants();
-    });
-
-    it('grant moderator and validate', async () => {
-        const { p1, p2 } = ctx;
-
-        if (!await p1.isModerator()) {
-            ctx.skipSuiteTests = true;
-
-            return;
-        }
-
-        if (await p2.isModerator()) {
-            ctx.skipSuiteTests = true;
-
-            return;
-        }
-
-        await p1.getFilmstrip().grantModerator(p2);
-
-        await p2.driver.waitUntil(
-            () => p2.isModerator(),
-            {
-                timeout: 3000,
-                timeoutMsg: 'p2 did not become moderator'
-            }
-        );
-
-    });
-});

tests/specs/2way/kick.spec.ts

@@ -1,44 +0,0 @@
-import { ensureTwoParticipants } from '../../helpers/participants';
-
-describe('Kick', () => {
-    it('joining the meeting', async () => {
-        await ensureTwoParticipants();
-
-        if (!await ctx.p1.isModerator()) {
-            ctx.skipSuiteTests = true;
-        }
-    });
-
-    it('kick and check', () => kickParticipant2AndCheck());
-
-    it('kick p2p and check', async () => {
-        await ensureTwoParticipants({
-            configOverwrite: {
-                p2p: {
-                    enabled: true
-                }
-            }
-        });
-
-        await kickParticipant2AndCheck();
-    });
-});
-
-/**
- * Kicks the second participant and checks that the participant is removed from the conference and that dialog is open.
- */
-async function kickParticipant2AndCheck() {
-    const { p1, p2 } = ctx;
-
-    await p1.getFilmstrip().kickParticipant(await p2.getEndpointId());
-
-    await p1.waitForParticipants(0);
-
-    // check that the kicked participant sees the kick reason dialog
-    // let's wait for this to appear at least 2 seconds
-    await p2.driver.waitUntil(
-        async () => p2.isLeaveReasonDialogOpen(), {
-            timeout: 2000,
-            timeoutMsg: 'No leave reason dialog shown for p2'
-        });
-}

tests/specs/3way/audioVideoModeration.spec.ts

@@ -1,5 +1,5 @@
 import { Participant } from '../../helpers/Participant';
-import { config } from '../../helpers/TestsConfig';
+import { expectations } from '../../helpers/expectations';
 import {
     ensureOneParticipant,
     ensureThreeParticipants, ensureTwoParticipants,
@@ -79,7 +79,7 @@ describe('AVModeration', () => {
     it('hangup and change moderator', async () => {
         // The test below is only correct when the environment is configured to automatically elect a new moderator
         // when the moderator leaves. For environments where this is not the case, the test is skipped.
-        if (!config.autoModerator) {
+        if (!expectations.autoModerator) {
             return;
         }
 

tests/specs/3way/lobby.spec.ts

@@ -1,5 +1,5 @@
 import { P1, P3, Participant } from '../../helpers/Participant';
-import { config } from '../../helpers/TestsConfig';
+import { expectations } from '../../helpers/expectations';
 import {
     ensureOneParticipant,
     ensureThreeParticipants,
@@ -198,7 +198,7 @@ describe('Lobby', () => {
     it('change of moderators in lobby', async () => {
         // The test below is only correct when the environment is configured to automatically elect a new moderator
         // when the moderator leaves. For environments where this is not the case, the test is skipped.
-        if (!config.autoModerator) {
+        if (!expectations.autoModerator) {
             return;
         }
         await hangupAllParticipants();
@@ -291,7 +291,7 @@ describe('Lobby', () => {
     it('moderator leaves while lobby enabled', async () => {
         // The test below is only correct when the environment is configured to automatically elect a new moderator
         // when the moderator leaves. For environments where this is not the case, the test is skipped.
-        if (!config.autoModerator) {
+        if (!expectations.autoModerator) {
             return;
         }
         const { p1, p2, p3 } = ctx;

tests/specs/3way/startMuted.spec.ts

@@ -139,6 +139,9 @@ describe('StartMuted', () => {
         await p3.getParticipantsPane().assertVideoMuteIconIsDisplayed(p2, true);
 
         // Unmute and see if the audio works
+        // we need 1 and 2 to be muted so we have a dominant speaker event for correct audio levels calculations
+        await p1.getToolbar().clickAudioMuteButton();
+        await p2.getToolbar().clickAudioMuteButton();
         await p3.getToolbar().clickAudioUnmuteButton();
         p1.log('configOptionsTest, unmuted third participant');
         await p1.waitForAudioMuted(p3, false /* unmuted */);

tests/specs/alone/dialInAudio.spec.ts

@@ -1,6 +1,7 @@
 import process from 'node:process';
 
 import { config as testsConfig } from '../../helpers/TestsConfig';
+import { expectations } from '../../helpers/expectations';
 import { ensureOneParticipant } from '../../helpers/participants';
 import { cleanup, dialIn, isDialInEnabled, waitForAudioFromDialInParticipant } from '../helpers/DialIn';
 
@@ -25,7 +26,14 @@ describe('Dial-In', () => {
 
         expect(await ctx.p1.isInMuc()).toBe(true);
 
-        if (!await isDialInEnabled(ctx.p1)) {
+        const configEnabled = await isDialInEnabled(ctx.p1);
+
+        if (expectations.dialIn.enabled !== null) {
+            expect(configEnabled).toBe(expectations.dialIn.enabled);
+        }
+
+        if (!configEnabled) {
+            console.log('Dial in config is disabled, skipping dial-in tests');
             ctx.skipSuiteTests = true;
         }
     });

tests/specs/alone/invite.spec.ts

@@ -1,11 +1,11 @@
 import { Participant } from '../../helpers/Participant';
 import { config as testsConfig } from '../../helpers/TestsConfig';
+import { expectations } from '../../helpers/expectations';
 import { ensureOneParticipant } from '../../helpers/participants';
 import { assertDialInDisplayed, assertUrlDisplayed, isDialInEnabled, verifyMoreNumbersPage } from '../helpers/DialIn';
 
 describe('Invite', () => {
     let p1: Participant;
-    let dialInEnabled: boolean;
 
     it('setup', async () => {
         // This is a temporary hack to avoid failing when running against a jaas env. The same cases are covered in
@@ -19,23 +19,30 @@ describe('Invite', () => {
         await ensureOneParticipant();
 
         p1 = ctx.p1;
-        dialInEnabled = await isDialInEnabled(p1);
+
     });
 
+    // The URL should always be displayed.
     it('url displayed', () => assertUrlDisplayed(p1));
 
-    it('dial-in displayed', async () => {
-        if (!dialInEnabled) {
-            return;
+    it('config values', async () => {
+        const dialInEnabled = await isDialInEnabled(p1);
+
+        if (expectations.dialIn.enabled !== null) {
+            expect(dialInEnabled).toBe(expectations.dialIn.enabled);
+        }
+    });
+
+    it('dial-in displayed', async () => {
+        if (expectations.dialIn.enabled !== null) {
+            await assertDialInDisplayed(p1, expectations.dialIn.enabled);
         }
-        await assertDialInDisplayed(p1);
     });
 
     it('view more numbers page', async () => {
-        if (!dialInEnabled) {
-            return;
+        if (expectations.dialIn.enabled === true) {
+            // TODO: assert the page is NOT shown when the expectation is false.
+            await verifyMoreNumbersPage(p1);
         }
-
-        await verifyMoreNumbersPage(p1);
     });
 });

tests/specs/helpers/DialIn.ts

@@ -95,14 +95,14 @@ export async function assertUrlDisplayed(p: Participant) {
     await inviteDialog.waitTillOpen(true);
 }
 
-export async function assertDialInDisplayed(p: Participant) {
+export async function assertDialInDisplayed(p: Participant, displayed: boolean = false) {
     const inviteDialog = p.getInviteDialog();
 
     await inviteDialog.open();
     await inviteDialog.waitTillOpen();
 
-    expect((await inviteDialog.getDialInNumber()).length > 0).toBe(true);
-    expect((await inviteDialog.getPinNumber()).length > 0).toBe(true);
+    expect((await inviteDialog.getDialInNumber()).length > 0).toBe(displayed);
+    expect((await inviteDialog.getPinNumber()).length > 0).toBe(displayed);
 }
 
 export async function verifyMoreNumbersPage(p: Participant) {

tests/specs/jaas/dial/dialin.spec.ts

@@ -2,6 +2,7 @@ import type { Participant } from '../../../helpers/Participant';
 import { setTestProperties } from '../../../helpers/TestProperties';
 import { config as testsConfig } from '../../../helpers/TestsConfig';
 import WebhookProxy from '../../../helpers/WebhookProxy';
+import { expectations } from '../../../helpers/expectations';
 import { joinJaasMuc, generateJaasToken as t } from '../../../helpers/jaas';
 import {
     assertDialInDisplayed, assertUrlDisplayed,
@@ -34,14 +35,21 @@ describe('Dial-in', () => {
         webhooksProxy = ctx.webhooksProxy;
 
         expect(await p1.isInMuc()).toBe(true);
-        expect(await isDialInEnabled(p1)).toBe(true);
+        if (expectations.dialIn.enabled !== null) {
+            expect(await isDialInEnabled(p1)).toBe(expectations.dialIn.enabled);
+        }
         expect(customerId).toBeDefined();
     });
 
     it ('Invite UI', async () => {
         await assertUrlDisplayed(p1);
-        await assertDialInDisplayed(p1);
-        await verifyMoreNumbersPage(p1);
+        if (expectations.dialIn.enabled !== null) {
+            await assertDialInDisplayed(p1, expectations.dialIn.enabled);
+        }
+        if (expectations.dialIn.enabled === true) {
+            // TODO: assert the page is NOT shown when the expectation is false.
+            await verifyMoreNumbersPage(p1);
+        }
     });
 
     it('dial-in', async () => {

tests/specs/jaas/joinMuc.spec.ts

@@ -1,4 +1,5 @@
 import { setTestProperties } from '../../helpers/TestProperties';
+import { expectations } from '../../helpers/expectations';
 import { joinJaasMuc, generateJaasToken as t } from '../../helpers/jaas';
 import { TOKEN_AUTH_FAILED_TEST_ID, TOKEN_AUTH_FAILED_TITLE_TEST_ID } from '../../pageobjects/Notifications';
 
@@ -86,11 +87,15 @@ describe('XMPP login and MUC join test', () => {
         console.log('Joining a MUC without a token');
         const p = await joinJaasMuc();
 
-        expect(Boolean(await p.isInMuc())).toBe(false);
+        if (expectations.jaas.unauthenticatedJoins) {
+            expect(Boolean(await p.isInMuc())).toBe(true);
+        } else {
+            expect(Boolean(await p.isInMuc())).toBe(false);
 
-        const errorText = await p.getNotifications().getNotificationText(TOKEN_AUTH_FAILED_TEST_ID);
+            const errorText = await p.getNotifications().getNotificationText(TOKEN_AUTH_FAILED_TEST_ID);
 
-        expect(errorText).toContain('not allowed to join');
+            expect(errorText).toContain('not allowed to join');
+        }
     });
 
     // it('without sending a conference-request', async () => {

tests/specs/moderation/grantModerator.spec.ts

@@ -0,0 +1,55 @@
+import { Participant } from '../../helpers/Participant';
+import { setTestProperties } from '../../helpers/TestProperties';
+import { expectations } from '../../helpers/expectations';
+import { ensureOneParticipant, ensureTwoParticipants } from '../../helpers/participants';
+
+setTestProperties(__filename, {
+    usesBrowsers: [ 'p1', 'p2' ]
+});
+
+describe('Grant moderator', () => {
+    let p1: Participant, p2: Participant;
+
+    it('setup', async () => {
+        if (expectations.moderation.allModerators) {
+            ctx.skipSuiteTests = true;
+            console.log('Skipping because allModerators is expected.');
+
+            return;
+        }
+
+        await ensureOneParticipant();
+        p1 = ctx.p1;
+        expect(await p1.isModerator()).toBe(true);
+
+        const functionAvailable = await p1.execute(() => typeof APP.conference._room.grantOwner === 'function');
+
+        if (expectations.moderation.grantModerator) {
+            expect(functionAvailable).toBe(true);
+        } else {
+            if (!functionAvailable) {
+                ctx.skipSuiteTests = true;
+                console.log('Skipping because the grant moderator function is not available and not expected.');
+
+                return;
+            }
+        }
+
+        await ensureTwoParticipants();
+        p2 = ctx.p2;
+        expect(await p2.isModerator()).toBe(false);
+    });
+
+    it('grant moderator', async () => {
+        await p1.getFilmstrip().grantModerator(p2);
+
+        await p2.driver.waitUntil(
+            () => p2.isModerator(),
+            {
+                timeout: 3000,
+                timeoutMsg: 'p2 did not become moderator'
+            }
+        );
+
+    });
+});

tests/specs/moderation/kick.spec.ts

@@ -0,0 +1,75 @@
+import { Participant } from '../../helpers/Participant';
+import { setTestProperties } from '../../helpers/TestProperties';
+import { expectations } from '../../helpers/expectations';
+import { ensureTwoParticipants } from '../../helpers/participants';
+
+setTestProperties(__filename, {
+    usesBrowsers: [ 'p1', 'p2' ]
+});
+
+describe('Kick', () => {
+    let p1: Participant, p2: Participant;
+
+    it('setup', async () => {
+        await ensureTwoParticipants();
+        p1 = ctx.p1;
+        p2 = ctx.p2;
+
+        // We verify elsewhere (moderation.spec.ts) that the first participant is a moderator.
+        if (!await p1.isModerator()) {
+            ctx.skipSuiteTests = true;
+        }
+    });
+
+    it('kick (p2p disabled)', () => kickAndCheck(p1, p2));
+
+    it('setup (p2p enabled)', async () => {
+        await p1.hangup();
+        await p2.hangup();
+
+        await ensureTwoParticipants({
+            configOverwrite: {
+                p2p: {
+                    enabled: true
+                }
+            }
+        });
+        p1 = ctx.p1;
+        p2 = ctx.p2;
+    });
+
+    it('kick (p2p enabled)', async () => {
+        await kickAndCheck(p1, p2);
+    });
+
+    it('non-moderator cannot kick', async () => {
+        if (!expectations.moderation.allModerators) {
+            await ensureTwoParticipants();
+            p2 = ctx.p2;
+            expect(await p2.isModerator()).toBe(false);
+
+            await p2.execute(
+                epId => APP.conference._room.kickParticipant(epId, 'for funzies'),
+                await p1.getEndpointId()
+            );
+
+            await p1.driver.pause(3000);
+            expect(await p1.isInMuc()).toBe(true);
+        }
+    });
+});
+
+/**
+ * Kicks the second participant and checks that the participant is removed from the conference and that dialogue is open.
+ */
+async function kickAndCheck(kicker: Participant, kickee: Participant) {
+    await kicker.getFilmstrip().kickParticipant(await kickee.getEndpointId());
+    await kicker.waitForParticipants(0);
+
+    // check that the kicked participant sees the kick reason dialog
+    await kickee.driver.waitUntil(
+        async () => kickee.isLeaveReasonDialogOpen(), {
+            timeout: 2000,
+            timeoutMsg: 'No leave reason dialog shown for p2'
+        });
+}

tests/specs/moderation/moderation.spec.ts

@@ -0,0 +1,39 @@
+import { Participant } from '../../helpers/Participant';
+import { setTestProperties } from '../../helpers/TestProperties';
+import { expectations } from '../../helpers/expectations';
+import { joinMuc } from '../../helpers/joinMuc';
+
+setTestProperties(__filename, {
+    usesBrowsers: [ 'p1', 'p2' ]
+});
+
+// Just make sure that users are given moderator rights as specified in the expectations config.
+describe('Moderation', () => {
+    let p1: Participant, p2: Participant;
+
+    it('setup', async () => {
+        p1 = await joinMuc({ name: 'p1' });
+        p2 = await joinMuc({ name: 'p2' });
+    });
+    it('first moderator', async () => {
+        if (expectations.moderation.firstModerator) {
+            expect(await p1.isModerator()).toBe(true);
+        } else {
+            expect(await p1.isModerator()).toBe(false);
+        }
+    });
+    it('all moderators', async () => {
+        if (expectations.moderation.allModerators) {
+            expect(await p1.isModerator()).toBe(true);
+            expect(await p2.isModerator()).toBe(true);
+        }
+    });
+    it('auto moderator promotion', async () => {
+        if (expectations.moderation.autoModerator && !expectations.moderation.allModerators) {
+            expect(await p1.isModerator()).toBe(true);
+            expect(await p2.isModerator()).toBe(false);
+            await p1.hangup();
+            await p2.driver.waitUntil(async () => (await p2.isModerator()));
+        }
+    });
+});