feat(tests): Adds dial-in test. (#15470)

* feat(tests): Adds dial-in test.

* feat(tests): Adds fake dial-in test.

* squash: switch to performance.now().

package.json

     "tsc-test:native": "tsc --project tsconfig.native.json --listFilesOnly | grep -v node_modules | grep web",
     "start": "make dev",
     "test": "DOTENV_CONFIG_PATH=tests/.env wdio run tests/wdio.conf.ts",
+    "test-single": "DOTENV_CONFIG_PATH=tests/.env wdio run tests/wdio.conf.ts --spec",
     "test-ff": "DOTENV_CONFIG_PATH=tests/.env wdio run tests/wdio.firefox.conf.ts",
     "test-dev": "DOTENV_CONFIG_PATH=tests/.env wdio run tests/wdio.dev.conf.ts",
-    "test-grid": "DOTENV_CONFIG_PATH=tests/.env wdio run tests/wdio.grid.conf.ts"
+    "test-grid": "DOTENV_CONFIG_PATH=tests/.env wdio run tests/wdio.grid.conf.ts",
+    "test-grid-single": "DOTENV_CONFIG_PATH=tests/.env wdio run tests/wdio.grid.conf.ts --spec"
   },
   "resolutions": {
     "@types/react": "17.0.14",

tests/helpers/Participant.ts

 import ChatPanel from '../pageobjects/ChatPanel';
 import Filmstrip from '../pageobjects/Filmstrip';
 import IframeAPI from '../pageobjects/IframeAPI';
+import InviteDialog from '../pageobjects/InviteDialog';
 import Notifications from '../pageobjects/Notifications';
 import ParticipantsPane from '../pageobjects/ParticipantsPane';
 import SettingsDialog from '../pageobjects/SettingsDialog';
      *
      * @returns {Promise<void>}
      */
-    async waitForSendReceiveData(): Promise<void> {
+    async waitForSendReceiveData(timeout = 15_000, msg = 'expected to receive/send data in 15s'): Promise<void> {
         const driver = this.driver;
 
         return driver.waitUntil(async () =>
 
                 return rtpStats.uploadBitrate > 0 && rtpStats.downloadBitrate > 0;
             }), {
-            timeout: 15_000,
-            timeoutMsg: 'expected to receive/send data in 15s'
+            timeout,
+            timeoutMsg: msg
         });
     }
 
     /**
      * Waits for remote streams.
      *
-     * @param {number} number - The number of remote streams o wait for.
+     * @param {number} number - The number of remote streams to wait for.
      * @returns {Promise<void>}
      */
     waitForRemoteStreams(number: number): Promise<void> {
         });
     }
 
+    /**
+     * Waits for number of participants.
+     *
+     * @param {number} number - The number of participant to wait for.
+     * @param {string} msg - A custom message to use.
+     * @returns {Promise<void>}
+     */
+    waitForParticipants(number: number, msg?: string): Promise<void> {
+        const driver = this.driver;
+
+        return driver.waitUntil(async () =>
+            await driver.execute(count => APP.conference.listMembers().length === count, number), {
+            timeout: 15_000,
+            timeoutMsg: msg || `not the expected participants ${number} in 15s`
+        });
+    }
+
     /**
      * Returns the chat panel for this participant.
      */
         return new Filmstrip(this);
     }
 
+    /**
+     * Returns the invite dialog for this participant.
+     *
+     * @returns {InviteDialog}
+     */
+    getInviteDialog(): InviteDialog {
+        return new InviteDialog(this);
+    }
+
     /**
      * Returns the notifications.
      */

tests/helpers/types.ts

 
 export type IContext = {
     conferenceJid: string;
+    dialInPin: string;
     iframeAPI: boolean;
     jwtKid: string;
     jwtPrivateKeyPath: string;
     p4: Participant;
     roomName: string;
     skipSuiteTests: boolean;
+    times: any;
     webhooksProxy: WebhookProxy;
 };
 

tests/pageobjects/Filmstrip.ts

         const popoverElement = this.participant.driver.$(
             `//div[contains(@class, 'popover')]//div[contains(@class, '${linkClassname}')]`);
 
+        await popoverElement.waitForExist();
         await popoverElement.waitForDisplayed();
         await popoverElement.click();
 
         await this.clickOnRemoteMenuLink(await participant.getEndpointId(), 'mutevideolink', true);
     }
 
+    /**
+     * Kicks a participant.
+     * @param participantId
+     */
+    async kickParticipant(participantId: string) {
+        await this.clickOnRemoteMenuLink(participantId, 'kicklink', true);
+    }
+
     /**
      * Clicks on the hide self view button from local video.
      */

tests/pageobjects/InviteDialog.ts

+import BaseDialog from './BaseDialog';
+
+const CONFERENCE_ID = 'conference-id';
+const DIALOG_CONTAINER = 'invite-more-dialog';
+
+/**
+ * Represents the invite dialog in a particular participant.
+ */
+export default class InviteDialog extends BaseDialog {
+    /**
+     * Checks if the dialog is open.
+     */
+    async isOpen() {
+        return this.participant.driver.$(`.${DIALOG_CONTAINER}`).isExisting();
+    }
+
+    /**
+     * Open the invite dialog, if the info dialog is closed.
+     */
+    async open() {
+        if (await this.isOpen()) {
+            return;
+        }
+
+        await this.participant.getParticipantsPane().clickInvite();
+    }
+
+    /**
+     * Returns the PIN for the conference.
+     */
+    async getPinNumber() {
+        await this.open();
+
+        const elem = this.participant.driver.$(`.${CONFERENCE_ID}`);
+
+        await elem.waitForExist({ timeout: 5000 });
+
+        const fullText = await elem.getText();
+
+        this.participant.log(`Extracted text in invite dialog: ${fullText}`);
+
+        return fullText.split(':')[1].trim().replace(/[# ]/g, '');
+    }
+}

tests/pageobjects/ParticipantsPane.ts

  */
 const PARTICIPANTS_PANE = 'participants_pane';
 
+const INVITE = 'Invite someone';
+
 /**
  * Represents the participants pane from the UI.
  */
         await meetingParticipantMoreOptions.moveTo();
         await meetingParticipantMoreOptions.click();
     }
+
+    /**
+     * Clicks the invite button.
+     */
+    async clickInvite() {
+        if (!await this.isOpen()) {
+            await this.open();
+        }
+
+        const inviteButton = this.participant.driver.$(`aria/${INVITE}`);
+
+        await inviteButton.waitForDisplayed();
+        await inviteButton.click();
+    }
 }

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

+import process from 'node:process';
+
+import { ensureOneParticipant, ensureTwoParticipants } from '../../helpers/participants';
+import { cleanup, waitForAudioFromDialInParticipant } from '../helpers/DialIn';
+
+describe('Fake Dial-In - ', () => {
+    it('join participant', async () => {
+        // we execute fake dial in only if the real dial in is not enabled
+
+        // check rest url is not configured
+        if (process.env.DIAL_IN_REST_URL) {
+            ctx.skipSuiteTests = true;
+
+            return;
+        }
+
+        await ensureOneParticipant(ctx);
+
+        // check dial-in is enabled, so skip
+        if (await ctx.p1.driver.execute(() => Boolean(
+            config.dialInConfCodeUrl && config.dialInNumbersUrl && config.hosts && config.hosts.muc))) {
+            ctx.skipSuiteTests = true;
+        }
+    });
+
+    it('open invite dialog', async () => {
+        await ctx.p1.getInviteDialog().open();
+
+        await ctx.p1.getInviteDialog().clickCloseButton();
+    });
+
+    it('invite second participant', async () => {
+        if (!await ctx.p1.isInMuc()) {
+            // local participant did not join abort
+            return;
+        }
+
+        await ensureTwoParticipants(ctx);
+    });
+
+    it('wait for audio from second participant', async () => {
+        const { p1 } = ctx;
+
+        if (!await p1.isInMuc()) {
+            // local participant did not join abort
+            return;
+        }
+
+        await waitForAudioFromDialInParticipant(p1);
+
+        await cleanup(p1);
+    });
+});

tests/specs/alone/dialInAudio.spec.ts

+import https from 'node:https';
+import process from 'node:process';
+
+import { ensureOneParticipant } from '../../helpers/participants';
+import { cleanup, waitForAudioFromDialInParticipant } from '../helpers/DialIn';
+
+describe('Dial-In - ', () => {
+    it('join participant', async () => {
+        // check rest url is configured
+        if (!process.env.DIAL_IN_REST_URL) {
+            ctx.skipSuiteTests = true;
+
+            return;
+        }
+
+        await ensureOneParticipant(ctx);
+
+        // check dial-in is enabled
+        if (!await ctx.p1.driver.execute(() => Boolean(
+            config.dialInConfCodeUrl && config.dialInNumbersUrl && config.hosts && config.hosts.muc))) {
+            ctx.skipSuiteTests = true;
+        }
+    });
+
+    it('retrieve pin', async () => {
+        const dialInPin = await ctx.p1.getInviteDialog().getPinNumber();
+
+        await ctx.p1.getInviteDialog().clickCloseButton();
+
+        if (dialInPin.length === 0) {
+            console.error('dial-in.test.no-pin');
+        }
+
+        expect(dialInPin.length >= 9).toBe(true);
+
+        ctx.dialInPin = dialInPin;
+    });
+
+    it('invite dial-in participant', async () => {
+        if (!await ctx.p1.isInMuc()) {
+            // local participant did not join abort
+            return;
+        }
+
+        const restUrl = process.env.DIAL_IN_REST_URL?.replace('{0}', ctx.dialInPin);
+
+        // we have already checked in the first test that DIAL_IN_REST_URL exist so restUrl cannot be ''
+        const responseData: string = await new Promise((resolve, reject) => {
+            https.get(restUrl || '', res => {
+                let data = '';
+
+                res.on('data', chunk => {
+                    data += chunk;
+                });
+
+                res.on('end', () => {
+                    ctx.times.restAPIExecutionTS = performance.now();
+
+                    resolve(data);
+                });
+            }).on('error', err => {
+                console.error('dial-in.test.restAPI.request.fail');
+                console.error(err);
+                reject(err);
+            });
+        });
+
+        console.log(`dial-in.test.call_session_history_id:${JSON.parse(responseData).call_session_history_id}`);
+    });
+
+    it('wait for audio from dial-in participant', async () => {
+        const { p1 } = ctx;
+
+        if (!await p1.isInMuc()) {
+            // local participant did not join abort
+            return;
+        }
+
+        await waitForAudioFromDialInParticipant(p1);
+
+        await cleanup(p1);
+    });
+});

tests/specs/helpers/DialIn.ts

+import type { Participant } from '../../helpers/Participant';
+
+/**
+ * Helper functions for dial-in related operations.
+ * To be able to create a fake dial-in test that will run most of the logic for the real dial-in test.
+ */
+
+/**
+ * Waits for the audio from the dial-in participant.
+ * @param participant
+ */
+export async function waitForAudioFromDialInParticipant(participant: Participant) {
+    // waits 15 seconds for the participant to join
+    await participant.waitForParticipants(1, `dial-in.test.jigasi.participant.no.join.for:${
+        ctx.times.restAPIExecutionTS + 15_000} ms.`);
+
+    const joinedTS = performance.now();
+
+    console.log(`dial-in.test.jigasi.participant.join.after:${joinedTS - ctx.times.restAPIExecutionTS}`);
+
+    await participant.waitForIceConnected();
+    await participant.waitForRemoteStreams(1);
+
+    await participant.waitForSendReceiveData(20_000, 'dial-in.test.jigasi.participant.no.audio.after.join');
+    console.log(`dial-in.test.jigasi.participant.received.audio.after.join:${performance.now() - joinedTS} ms.`);
+}
+
+/**
+ * Cleans up the dial-in participant by kicking it if the local participant is a moderator.
+ * @param participant
+ */
+export async function cleanup(participant: Participant) {
+    // cleanup
+    if (await participant.isModerator()) {
+        const jigasiEndpointId = await participant.driver.execute(() => APP.conference.listMembers()[0].getId());
+
+        await participant.getFilmstrip().kickParticipant(jigasiEndpointId);
+    }
+}

tests/wdio.conf.ts

         const globalAny: any = global;
         const roomName = `jitsimeettorture-${crypto.randomUUID()}`;
 
-        globalAny.ctx = {} as IContext;
+        globalAny.ctx = {
+            times: {}
+        } as IContext;
         globalAny.ctx.roomName = roomName;
         globalAny.ctx.jwtPrivateKeyPath = process.env.JWT_PRIVATE_KEY_PATH;
         globalAny.ctx.jwtKid = process.env.JWT_KID;