import { expect } from 'chai';
import { Builder, Key, WebDriver } from 'selenium-webdriver';
import { OPENVIDU_SECRET, OPENVIDU_SERVER_URL } from './config';
import { getBrowserOptionsWithoutDevices, WebComponentConfig } from './selenium.conf';
import { OpenViduComponentsPO } from './utils.po.test';

const url = `${WebComponentConfig.appUrl}?OV_URL=${OPENVIDU_SERVER_URL}&OV_SECRET=${OPENVIDU_SECRET}`;

describe('Testing API Directives', () => {
	let browser: WebDriver;
	let utils: OpenViduComponentsPO;
	async function createChromeBrowser(): Promise<WebDriver> {
		return await new Builder()
			.forBrowser(WebComponentConfig.browserName)
			.withCapabilities(WebComponentConfig.browserCapabilities)
			.setChromeOptions(WebComponentConfig.browserOptions)
			.usingServer(WebComponentConfig.seleniumAddress)
			.build();
	}

	beforeEach(async () => {
		browser = await createChromeBrowser();
		utils = new OpenViduComponentsPO(browser);
	});

	afterEach(async () => {
		// console.log('data:image/png;base64,' + await browser.takeScreenshot());
		await browser.quit();
	});

	it('should join with ONLY ONE TOKEN', async () => {
		await browser.get(`${url}&singleToken=true`);

		// Checking if prejoin page exist
		await utils.checkPrejoinIsPresent();

		const joinButton = await utils.waitForElement('#join-button');
		await joinButton.click();

		// Checking if session container is present
		await utils.checkSessionIsPresent();

		await utils.checkToolbarIsPresent();

		// Checking if screenshare button is not present
		expect(await utils.isPresent('#screenshare-btn')).to.be.false;
	});

	it('should set the MINIMAL UI', async () => {
		await browser.get(`${url}&minimal=true`);
		// Checking if prejoin page exist
		await utils.checkPrejoinIsPresent();

		// Checking if layout is present
		await utils.checkLayoutPresent();

		// Checking if stream component is present
		utils.checkStreamIsPresent();

		// Checking if audio detection is not displayed
		expect(await utils.isPresent('#audio-wave-container')).to.be.false;

		const joinButton = await utils.waitForElement('#join-button');
		await joinButton.click();

		// Checking if session container is present
		await utils.checkSessionIsPresent();

		// Checking if toolbar is present
		await utils.checkToolbarIsPresent();

		// Checking if screenshare button is not present
		expect(await utils.isPresent('#screenshare-btn')).to.be.false;

		// Checking if more options button is not present
		expect(await utils.isPresent('#more-options-btn')).to.be.false;

		// Checking if participants panel button is not present
		expect(await utils.isPresent('#participants-panel-btn')).to.be.false;

		// Checking if activities panel button is not present
		expect(await utils.isPresent('#activities-panel-btn')).to.be.false;

		// Checking if logo is not displayed
		expect(await utils.isPresent('#branding-logo')).to.be.false;

		// Checking if session name is not displayed
		expect(await utils.isPresent('#session-name')).to.be.false;

		// Checking if nickname is not displayed
		expect(await utils.getNumberOfElements('#nickname-container')).equals(0);

		// Checking if audio detection is not displayed
		expect(await utils.isPresent('#audio-wave-container')).to.be.false;

		// Checking if settings button is not displayed
		expect(await utils.isPresent('#settings-container')).to.be.false;
	});

	it('should change the UI LANG ', async () => {
		await browser.get(`${url}&lang=es`);

		await utils.checkPrejoinIsPresent();

		let element = await utils.waitForElement('.lang-button');
		expect(await element.getText()).equal('Españolexpand_more');

		element = await utils.waitForElement('#join-button');
		expect(await element.getText()).equal('Unirme ahora');
	});

	it('should show the PREJOIN page', async () => {
		await browser.get(`${url}&prejoin=true`);

		await utils.checkPrejoinIsPresent();
	});

	it('should not show the PREJOIN page', async () => {
		await browser.get(`${url}&prejoin=false`);

		await utils.checkSessionIsPresent();
	});

	it('should run the app with VIDEO MUTED in prejoin page', async () => {
		try {
			let idVideoEnabled;
			const script = 'return document.getElementsByTagName("video")[0].srcObject.getVideoTracks()[0].enabled;';

			await browser.get(`${url}&prejoin=true&videoMuted=true`);

			await utils.checkPrejoinIsPresent();

			// Checking if video is displayed
			await utils.checkVideoElementIsPresent();

			// Checking if virtual background button is disabled
			const button = await utils.waitForElement('#background-effects-btn');
			expect(await button.isEnabled()).to.be.false;

			// Checking if video track is disabled/muted
			idVideoEnabled = await browser.executeScript<boolean>(script);
			expect(idVideoEnabled).to.be.false;

			await utils.waitForElement('#videocam_off');
			await utils.clickOn('#join-button');

			// Checking if video is muted after join the room
			await utils.checkSessionIsPresent();

			idVideoEnabled = await browser.executeScript<boolean>(script);
			expect(idVideoEnabled).to.be.false;

			await utils.waitForElement('#videocam_off');
			expect(await utils.isPresent('#videocam_off')).to.be.true;
		} catch (error) {
			console.log(error);
			console.log(await browser.takeScreenshot());
		}
	});

	it('should run the app with VIDEO MUTED and WITHOUT PREJOIN page', async () => {
		let isVideoEnabled;
		const videoEnableScript = 'return document.getElementsByTagName("video")[0].srcObject.getVideoTracks()[0].enabled;';

		await browser.get(`${url}&prejoin=false&videoMuted=true`);

		await browser.sleep(2000);

		await utils.checkSessionIsPresent();

		await utils.checkLayoutPresent();

		// Checking if video is displayed
		await utils.checkVideoElementIsPresent();

		// Checking if video track is disabled/muted
		isVideoEnabled = await browser.executeScript(videoEnableScript);
		expect(isVideoEnabled).to.be.false;

		await utils.waitForElement('#videocam_off');
		expect(await utils.isPresent('#videocam_off')).to.be.true;
	});

	it('should run the app with AUDIO MUTED in prejoin page', async () => {
		let isAudioEnabled;
		const script = 'return document.getElementsByTagName("video")[0].srcObject.getAudioTracks()[0].enabled;';

		await browser.get(`${url}&audioMuted=true`);

		await utils.checkPrejoinIsPresent();

		// Checking if video is displayed
		await utils.checkVideoElementIsPresent();

		// Checking if audio track is disabled/muted
		isAudioEnabled = await browser.executeScript(script);
		expect(isAudioEnabled).to.be.false;

		await utils.waitForElement('#mic_off');
		expect(await utils.isPresent('#mic_off')).to.be.true;

		await utils.clickOn('#join-button');

		// Checking if audio is muted after join the room
		await utils.checkSessionIsPresent();
		isAudioEnabled = await browser.executeScript(script);
		expect(isAudioEnabled).to.be.false;

		await utils.waitForElement('#mic_off');
		expect(await utils.isPresent('#mic_off')).to.be.true;
	});

	it('should run the app with VIDEO MUTED and WITHOUT PREJOIN page', async () => {
		let isAudioEnabled;
		const audioEnableScript = 'return document.getElementsByTagName("video")[0].srcObject.getAudioTracks()[0].enabled;';

		await browser.get(`${url}&prejoin=false&audioMuted=true`);

		await utils.checkSessionIsPresent();

		// Checking if video is displayed
		await utils.checkVideoElementIsPresent();

		// Checking if audio track is disabled/muted
		isAudioEnabled = await browser.executeScript(audioEnableScript);
		expect(isAudioEnabled).to.be.false;

		await utils.waitForElement('#mic_off');
		expect(await utils.isPresent('#mic_off')).to.be.true;
	});

	it('should HIDE the SCREENSHARE button', async () => {
		await browser.get(`${url}&prejoin=false&screenshareBtn=false`);

		await utils.checkSessionIsPresent();

		// Checking if toolbar is present
		await utils.checkToolbarIsPresent();

		// Checking if screenshare button is not present
		expect(await utils.isPresent('#screenshare-btn')).to.be.false;
	});

	it('should HIDE the FULLSCREEN button', async () => {
		await browser.get(`${url}&prejoin=false&fullscreenBtn=false`);

		await utils.checkSessionIsPresent();

		// Checking if toolbar is present
		await utils.checkToolbarIsPresent();

		// Open more options menu
		await utils.clickOn('#more-options-btn');

		await browser.sleep(500);

		// Checking if fullscreen button is not present
		await utils.waitForElement('.mat-menu-content');
		expect(await utils.isPresent('.mat-menu-content')).to.be.true;
		expect(await utils.getNumberOfElements('#fullscreen-btn')).equals(0);

	});

	it('should HIDE the CAPTIONS button', async () => {
		await browser.get(`${url}&prejoin=false&toolbarCaptionsBtn=false`);

		await utils.checkSessionIsPresent();

		// Checking if toolbar is present
		await utils.checkToolbarIsPresent();

		// Open more options menu
		await utils.clickOn('#more-options-btn');

		await browser.sleep(500);

		// Checking if button panel is present
		await utils.waitForElement('.mat-menu-content');
		expect(await utils.isPresent('.mat-menu-content')).to.be.true;

		// Checking if captions button is not present
		expect(await utils.isPresent('#captions-btn')).to.be.false;

		await utils.clickOn('#toolbar-settings-btn');

		await browser.sleep(500);

		await utils.waitForElement('.settings-container');
		expect(await utils.isPresent('.settings-container')).to.be.true;

		expect(await utils.isPresent('#captions-opt')).to.be.false;
	});

	it('should HIDE the TOOLBAR RECORDING button', async () => {
		await browser.get(`${url}&prejoin=false&toolbarRecordingButton=false`);

		await utils.checkSessionIsPresent();

		// Checking if toolbar is present
		await utils.checkToolbarIsPresent();

		// Open more options menu
		await utils.clickOn('#more-options-btn');

		await browser.sleep(500);

		// Checking if button panel is present
		await utils.waitForElement('.mat-menu-content');
		expect(await utils.isPresent('.mat-menu-content')).to.be.true;

		// Checking if recording button is not present
		expect(await utils.isPresent('#recording-btn')).to.be.false;
	});

	it('should HIDE the TOOLBAR BROADCASTING button', async () => {
		await browser.get(`${url}&prejoin=false&toolbarBroadcastingButton=false`);

		await utils.checkSessionIsPresent();

		// Checking if toolbar is present
		await utils.checkToolbarIsPresent();

		// Open more options menu
		await utils.clickOn('#more-options-btn');

		await browser.sleep(500);

		// Checking if button panel is present
		await utils.waitForElement('.mat-menu-content');
		expect(await utils.isPresent('.mat-menu-content')).to.be.true;

		// Checking if broadcasting button is not present
		expect(await utils.isPresent('#broadcasting-btn')).to.be.false;
	});

	it('should HIDE the TOOLBAR SETTINGS button', async () => {
		await browser.get(`${url}&prejoin=false&toolbarSettingsBtn=false`);

		await utils.checkSessionIsPresent();

		// Checking if toolbar is present
		await utils.checkToolbarIsPresent();

		// Open more options menu
		await utils.clickOn('#more-options-btn');

		await browser.sleep(500);

		// Checking if fullscreen button is not present
		await utils.waitForElement('.mat-menu-content');
		expect(await utils.isPresent('.mat-menu-content')).to.be.true;

		expect(await utils.isPresent('#toolbar-settings-btn')).to.be.false;
	});

	it('should HIDE the LEAVE button', async () => {
		await browser.get(`${url}&prejoin=false&leaveBtn=false`);

		await utils.checkSessionIsPresent();

		// Checking if toolbar is present
		await utils.checkToolbarIsPresent();

		// Checking if leave button is not present
		expect(await utils.getNumberOfElements('#leave-btn')).equals(0);
	});

	it('should HIDE the ACTIVITIES PANEL button', async () => {
		await browser.get(`${url}&prejoin=false&activitiesPanelBtn=false`);

		await utils.checkSessionIsPresent();

		// Checking if toolbar is present
		await utils.checkToolbarIsPresent();

		// Checking if activities panel button is not present
		expect(await utils.isPresent('#activities-panel-btn')).to.be.false;
	});

	it('should HIDE the CHAT PANEL button', async () => {
		await browser.get(`${url}&prejoin=false&chatPanelBtn=false`);

		await utils.checkSessionIsPresent();

		// Checking if toolbar is present
		await utils.checkToolbarIsPresent();

		// Checking if chat panel button is not present
		expect(await utils.isPresent('#chat-panel-btn')).to.be.false;
	});

	it('should HIDE the PARTICIPANTS PANEL button', async () => {
		await browser.get(`${url}&prejoin=false&participantsPanelBtn=false`);

		await utils.checkSessionIsPresent();

		// Checking if toolbar is present
		await utils.checkToolbarIsPresent();

		// Checking if participants panel button is not present
		expect(await utils.isPresent('#participants-panel-btn')).to.be.false;
	});

	it('should HIDE the LOGO', async () => {
		await browser.get(`${url}&prejoin=false&displayLogo=false`);

		await utils.checkSessionIsPresent();

		// Checking if toolbar is present
		await utils.checkToolbarIsPresent();

		// Checking if toolbar is present
		await utils.waitForElement('#info-container');
		expect(await utils.isPresent('#info-container')).to.be.true;

		// Checking if logo is not displayed
		expect(await utils.isPresent('#branding-logo')).to.be.false;
	});

	it('should HIDE the SESSION NAME', async () => {
		await browser.get(`${url}&prejoin=false&displaySessionName=false`);

		await utils.checkSessionIsPresent();

		// Checking if toolbar is present
		await utils.checkToolbarIsPresent();

		// Checking if toolbar is present
		await utils.waitForElement('#info-container');
		expect(await utils.isPresent('#info-container')).to.be.true;

		// Checking if session name is not displayed
		expect(await utils.isPresent('#session-name')).to.be.false;
	});

	it('should HIDE the PARTICIPANT NAME', async () => {
		await browser.get(`${url}&prejoin=false&displayParticipantName=false`);

		await utils.checkSessionIsPresent();

		// Checking if toolbar is present
		await utils.checkToolbarIsPresent();

		// Checking if stream component is present
		await utils.checkStreamIsPresent();

		// Checking if nickname is not present
		expect(await utils.isPresent('#nickname-container')).to.be.false;
	});

	it('should HIDE the AUDIO DETECTION element', async () => {
		await browser.get(`${url}&prejoin=false&displayAudioDetection=false`);

		await utils.checkSessionIsPresent();

		// Checking if toolbar is present
		await utils.checkToolbarIsPresent();

		// Checking if stream component is present
		await utils.checkStreamIsPresent();

		// Checking if audio detection is not present
		expect(await utils.isPresent('#audio-wave-container')).to.be.false;
	});

	it('should HIDE the STREAM SETTINGS button', async () => {
		await browser.get(`${url}&prejoin=false&settingsBtn=false`);

		await utils.checkSessionIsPresent();

		// Checking if toolbar is present
		await utils.checkToolbarIsPresent();

		// Checking if stream component is present
		await utils.checkStreamIsPresent();

		// Checking if settings button is not present
		expect(await utils.isPresent('#settings-container')).to.be.false;
	});

	it('should HIDE the MUTE button in participants panel', async () => {
		const sessionName = 'e2etest';
		const fixedUrl = `${url}&prejoin=false&participantMuteBtn=false&sessionName=${sessionName}`;
		await browser.get(fixedUrl);

		await utils.checkSessionIsPresent();

		// Checking if toolbar is present
		await utils.checkToolbarIsPresent();

		const participantsButton = await utils.waitForElement('#participants-panel-btn');
		await participantsButton.click();

		// Checking if participatns panel is displayed
		await utils.waitForElement('#participants-container');
		expect(await utils.isPresent('#participants-container')).to.be.true;

		// Checking remote participants item
		expect(await utils.isPresent('#remote-participant-item')).to.be.false;

		// Starting new browser for adding a new participant
		const newTabScript = `window.open("${fixedUrl}")`;
		await browser.executeScript(newTabScript);

		// Go to first tab
		const tabs = await browser.getAllWindowHandles();
		browser.switchTo().window(tabs[0]);

		// Checking if mute button is not displayed in participant item
		await utils.waitForElement('#remote-participant-item');
		expect(await utils.isPresent('#remote-participant-item')).to.be.true;

		expect(await utils.isPresent('#mute-btn')).to.be.false;
	});

	it('should HIDE the RECORDING ACTIVITY in activities panel', async () => {
		let element;
		const fixedUrl = `${url}&prejoin=false&activitiesPanelRecordingActivity=false`;
		await browser.get(fixedUrl);

		await utils.checkSessionIsPresent();

		// Checking if toolbar is present
		await utils.checkToolbarIsPresent();

		element = await utils.waitForElement('#activities-panel-btn');
		await element.click();

		// Checking if participatns panel is displayed
		await utils.waitForElement('#default-activities-panel');
		expect(await utils.isPresent('#default-activities-panel')).to.be.true;

		// await browser.sleep(1000);

		// Checking if recording activity exists
		await utils.waitForElement('.activities-body-container');
		expect(await utils.isPresent('ov-recording-activity')).to.be.false;
	});

	it('should SHOW a RECORDING ERROR in activities panel', async () => {
		let element;
		const fixedUrl = `${url}&prejoin=false&recordingError=TEST_ERROR`;
		await browser.get(fixedUrl);

		await utils.checkSessionIsPresent();

		// Checking if toolbar is present
		await utils.checkToolbarIsPresent();

		element = await utils.waitForElement('#activities-panel-btn');
		await element.click();

		// Checking if participatns panel is displayed
		await utils.waitForElement('#default-activities-panel');
		expect(await utils.isPresent('#default-activities-panel')).to.be.true;

		// Checking if recording activity exists
		await utils.waitForElement('#activities-container');
		await utils.waitForElement('.activities-body-container');

		await utils.waitForElement('ov-recording-activity');
		expect(await utils.isPresent('ov-recording-activity')).to.be.true;

		await utils.waitForElement('.failed');
		expect(await utils.isPresent('.failed')).to.be.true;

		// Open recording
		await browser.sleep(1000);
		element = await utils.waitForElement('ov-recording-activity');
		await element.click();

		element = await utils.waitForElement('.recording-error');
		expect(await element.getAttribute('innerText')).equal('"TEST_ERROR"');
		expect(await utils.isPresent('.recording-error')).to.be.true;
	});

	it('should SHOW a BROADCASTING ERROR in activities panel', async () => {
		let element;
		const fixedUrl = `${url}&prejoin=false&broadcastingError=TEST_ERROR`;
		await browser.get(fixedUrl);

		await utils.checkSessionIsPresent();

		// Checking if toolbar is present
		await utils.checkToolbarIsPresent();

		element = await utils.waitForElement('#activities-panel-btn');
		await element.click();

		// Checking if participatns panel is displayed
		await utils.waitForElement('#default-activities-panel');
		expect(await utils.isPresent('#default-activities-panel')).to.be.true;

		// Checking if broadcasting activity exists
		await utils.waitForElement('#activities-container');
		await utils.waitForElement('.activities-body-container');

		await utils.waitForElement('ov-broadcasting-activity');
		expect(await utils.isPresent('ov-broadcasting-activity')).to.be.true;

		const status = await utils.waitForElement('#broadcasting-status');
		expect(await status.getAttribute('innerText')).equals('FAILED');

		// Open broadcasting
		await browser.sleep(1000);
		await utils.clickOn('ov-broadcasting-activity');

		element = await utils.waitForElement('#broadcasting-error');
		expect(await element.getAttribute('innerText')).equal('TEST_ERROR');
	});

	it('should HIDE the BROADCASTING ACTIVITY in activities panel', async () => {
		await browser.get(`${url}&prejoin=false&activitiesPanelBroadcastingActivity=false`);

		await utils.checkSessionIsPresent();

		// Checking if toolbar is present
		await utils.checkToolbarIsPresent();

		await utils.waitForElement('#activities-panel-btn');
		await utils.clickOn('#activities-panel-btn');

		// Checking if participatns panel is displayed
		await utils.waitForElement('#default-activities-panel');
		expect(await utils.isPresent('#default-activities-panel')).to.be.true;

		// await browser.sleep(1000);

		// Checking if recording activity exists
		await utils.waitForElement('.activities-body-container');
		expect(await utils.isPresent('ov-broadcasting-activity')).to.be.false;
	});
});

describe('Testing videoconference EVENTS', () => {
	let browser: WebDriver;
	let utils: OpenViduComponentsPO;
	async function createChromeBrowser(): Promise<WebDriver> {
		return await new Builder()
			.forBrowser(WebComponentConfig.browserName)
			.withCapabilities(WebComponentConfig.browserCapabilities)
			.setChromeOptions(WebComponentConfig.browserOptions)
			.usingServer(WebComponentConfig.seleniumAddress)
			.build();
	}

	beforeEach(async () => {
		browser = await createChromeBrowser();
		utils = new OpenViduComponentsPO(browser);
	});

	afterEach(async () => {
		await browser.quit();
	});

	it('should receive the onJoinButtonClicked event', async () => {
		await browser.get(`${url}`);

		await utils.waitForElement('#prejoin-container');
		expect(await utils.isPresent('#prejoin-container')).to.be.true;

		// Clicking to join button
		await utils.waitForElement('#join-button');
		await utils.clickOn('#join-button');

		// Checking if onJoinButtonClicked has been received
		await utils.waitForElement('#onJoinButtonClicked');
		expect(await utils.isPresent('#onJoinButtonClicked')).to.be.true;
	});

	it('should receive the onToolbarLeaveButtonClicked event', async () => {
		await browser.get(`${url}&prejoin=false`);

		await utils.checkSessionIsPresent();

		await utils.checkToolbarIsPresent();

		// Clicking to leave button
		const leaveButton = await utils.waitForElement('#leave-btn');
		expect(await utils.isPresent('#leave-btn')).to.be.true;
		await leaveButton.click();

		// Checking if onToolbarLeaveButtonClicked has been received
		await utils.waitForElement('#onToolbarLeaveButtonClicked');
		expect(await utils.isPresent('#onToolbarLeaveButtonClicked')).to.be.true;
	});

	it('should receive the onToolbarCameraButtonClicked event', async () => {
		await browser.get(`${url}&prejoin=false`);

		await utils.checkSessionIsPresent();

		await utils.checkToolbarIsPresent();

		// Clicking to leave button
		const cameraButton = await utils.waitForElement('#camera-btn');
		expect(await utils.isPresent('#camera-btn')).to.be.true;
		await cameraButton.click();

		// Checking if onToolbarCameraButtonClicked has been received
		await utils.waitForElement('#onToolbarCameraButtonClicked');
		expect(await utils.isPresent('#onToolbarCameraButtonClicked')).to.be.true;
	});

	it('should receive the onToolbarMicrophoneButtonClicked event', async () => {
		await browser.get(`${url}&prejoin=false`);

		await utils.checkSessionIsPresent();

		await utils.checkToolbarIsPresent();

		// Clicking to mic button
		const micButton = await utils.waitForElement('#mic-btn');
		expect(await utils.isPresent('#mic-btn')).to.be.true;
		await micButton.click();

		// Checking if onToolbarMicrophoneButtonClicked has been received
		await utils.waitForElement('#onToolbarMicrophoneButtonClicked');
		expect(await utils.isPresent('#onToolbarMicrophoneButtonClicked')).to.be.true;
	});

	it('should receive the onToolbarScreenshareButtonClicked event', async () => {
		await browser.get(`${url}&prejoin=false`);

		await utils.checkSessionIsPresent();

		await utils.checkToolbarIsPresent();

		// Clicking to leave button
		const screenshareButton = await utils.waitForElement('#screenshare-btn');
		expect(await utils.isPresent('#screenshare-btn')).to.be.true;
		await screenshareButton.click();

		// Checking if onToolbarScreenshareButtonClicked has been received
		await utils.waitForElement('#onToolbarScreenshareButtonClicked');
		expect(await utils.isPresent('#onToolbarScreenshareButtonClicked')).to.be.true;
	});

	it('should receive the onToolbarFullscreenButtonClicked event', async () => {
		let element;
		await browser.get(`${url}&prejoin=false`);

		await utils.checkSessionIsPresent();

		await utils.checkToolbarIsPresent();

		// Open more options menu
		element = await utils.waitForElement('#more-options-btn');
		expect(await utils.isPresent('#more-options-btn')).to.be.true;
		await element.click();

		// Clicking to fullscreen button
		await utils.waitForElement('.mat-menu-content');

		const fullscreenButton = await utils.waitForElement('#fullscreen-btn');
		expect(await utils.isPresent('#fullscreen-btn')).to.be.true;
		await fullscreenButton.click();

		// Checking if onToolbarFullscreenButtonClicked has been received
		await utils.waitForElement('#onToolbarFullscreenButtonClicked');
		expect(await utils.isPresent('#onToolbarFullscreenButtonClicked')).to.be.true;
	});

	it('should receive the onToolbarChatPanelButtonClicked event', async () => {
		await browser.get(`${url}&prejoin=false`);

		await utils.checkSessionIsPresent();

		await utils.checkToolbarIsPresent();

		// Clicking to chat button
		const chatButton = await utils.waitForElement('#chat-panel-btn');
		await chatButton.click();

		// Checking if onToolbarChatPanelButtonClicked has been received
		await utils.waitForElement('#onToolbarChatPanelButtonClicked');
		expect(await utils.isPresent('#onToolbarChatPanelButtonClicked')).to.be.true;
	});

	it('should receive the onToolbarParticipantsPanelButtonClicked event', async () => {
		await browser.get(`${url}&prejoin=false`);

		await utils.checkSessionIsPresent();

		await utils.checkToolbarIsPresent();

		// Clicking to participants button
		const participantsButton = await utils.waitForElement('#participants-panel-btn');
		await participantsButton.click();

		// Checking if onToolbarParticipantsPanelButtonClicked has been received
		await utils.waitForElement('#onToolbarParticipantsPanelButtonClicked');
		expect(await utils.isPresent('#onToolbarParticipantsPanelButtonClicked')).to.be.true;
	});

	it('should receive the onToolbarActivitiesPanelButtonClicked event', async () => {
		await browser.get(`${url}&prejoin=false`);

		await utils.checkSessionIsPresent();

		await utils.checkToolbarIsPresent();

		// Clicking to activities button
		const activitiesButton = await utils.waitForElement('#activities-panel-btn');
		await activitiesButton.click();

		// Checking if onToolbarActivitiesPanelButtonClicked has been received
		await utils.waitForElement('#onToolbarActivitiesPanelButtonClicked');
		expect(await utils.isPresent('#onToolbarActivitiesPanelButtonClicked')).to.be.true;
	});

	it('should receive the onToolbarStartRecordingClicked event', async () => {
		await browser.get(`${url}&prejoin=false`);

		await utils.checkSessionIsPresent();
		await utils.checkToolbarIsPresent();

		// Open more options menu
		await utils.waitForElement('#more-options-btn');
		expect(await utils.isPresent('#more-options-btn')).to.be.true;
		await utils.clickOn('#more-options-btn');

		await browser.sleep(500);

		// Clicking to recording button
		await utils.waitForElement('.mat-menu-content');

		await utils.waitForElement('#recording-btn');
		expect(await utils.isPresent('#recording-btn')).to.be.true;
		await utils.clickOn('#recording-btn');

		// Checking if onToolbarStartRecordingClicked has been received
		await utils.waitForElement('#onToolbarStartRecordingClicked');
		expect(await utils.isPresent('#onToolbarStartRecordingClicked')).to.be.true;
	});

	// TODO: it needs an OpenVidu PRO
	// it('should receive the onToolbarStopBroadcastingClicked event', async () => {
	// 	await browser.get(`${url}&prejoin=false`);

	// 	await utils.checkSessionIsPresent();
	// 	await utils.checkToolbarIsPresent();

	// 	// Open more options menu
	// 	await utils.waitForElement('#more-options-btn');
	// 	expect(await utils.isPresent('#more-options-btn')).to.be.true;
	// 	await utils.clickOn('#more-options-btn');

	// 	await browser.sleep(500);

	// 	await utils.waitForElement('.mat-menu-content');

	// 	await utils.waitForElement('#broadcasting-btn');
	// 	await utils.clickOn('#broadcasting-btn');

	// 	await browser.sleep(500);

	// 	await utils.waitForElement('.sidenav-menu');
	// 	await utils.waitForElement('#activities-container');

	// 	await utils.waitForElement('#broadcasting-url-input');
	// 	const input = await utils.waitForElement('#broadcast-url-input');
	// 	await input.sendKeys('BroadcastUrl');
	// 	await utils.clickOn('#broadcasting-btn');

	// 	// Open more options menu
	// 	await utils.waitForElement('#more-options-btn');
	// 	expect(await utils.isPresent('#more-options-btn')).to.be.true;
	// 	await utils.clickOn('#more-options-btn');

	// 	await browser.sleep(500);

	// 	await utils.waitForElement('.mat-menu-content');

	// 	await utils.waitForElement('#broadcasting-btn');
	// 	await utils.clickOn('#broadcasting-btn');

	// 	// Checking if onToolbarStopBroadcastingClicked has been received
	// 	await utils.waitForElement('#onToolbarStopBroadcastingClicked');
	// 	expect(await utils.isPresent('#onToolbarStopBroadcastingClicked')).to.be.true;
	// });

	it('should receive the onActivitiesPanelStartRecordingClicked event', async () => {
		let element;
		await browser.get(`${url}&prejoin=false`);

		await utils.checkSessionIsPresent();

		await utils.checkToolbarIsPresent();

		// Open activities panel
		element = await utils.waitForElement('#activities-panel-btn');
		expect(await utils.isPresent('#activities-panel-btn')).to.be.true;
		await element.click();

		await browser.sleep(1000);

		// Open recording
		element = await utils.waitForElement('ov-recording-activity');
		await element.click();

		await browser.sleep(1000);

		// Clicking to recording button
		element = await utils.waitForElement('#start-recording-btn');
		expect(await element.isEnabled()).to.be.true;

		await element.click();

		// Checking if onActivitiesPanelStartRecordingClicked has been received
		await utils.waitForElement('#onActivitiesPanelStartRecordingClicked');
		expect(await utils.isPresent('#onActivitiesPanelStartRecordingClicked')).to.be.true;
	});

	it('should receive the PLAY and DELETE recording events', async () => {
		let element;
		await browser.get(`${url}&prejoin=false`);

		await utils.checkSessionIsPresent();

		await utils.checkToolbarIsPresent();

		// Clicking to activities button
		const activitiesButton = await utils.waitForElement('#activities-panel-btn');
		expect(await utils.isPresent('#activities-panel-btn')).to.be.true;
		await activitiesButton.click();

		await browser.sleep(1500);
		// Open recording
		element = await utils.waitForElement('ov-recording-activity');
		await element.click();

		await browser.sleep(1500);

		// Delete event
		element = await utils.waitForElement('#delete-recording-btn');
		expect(await utils.isPresent('#delete-recording-btn')).to.be.true;
		await element.click();

		element = await utils.waitForElement('#delete-recording-confirm-btn');
		expect(await utils.isPresent('#delete-recording-confirm-btn')).to.be.true;
		await element.click();

		await utils.waitForElement('#onActivitiesPanelDeleteRecordingClicked');
		expect(await utils.isPresent('#onActivitiesPanelDeleteRecordingClicked')).to.be.true;
	});

	it('should receive the onActivitiesPanelStartBroadcasting event', async () => {
		await browser.get(`${url}&prejoin=false`);

		await utils.checkSessionIsPresent();
		await utils.checkToolbarIsPresent();

		// Get activities button and click into it
		await utils.waitForElement('#activities-panel-btn');
		await utils.clickOn('#activities-panel-btn');
		await browser.sleep(500);

		await utils.waitForElement('.sidenav-menu');
		await utils.waitForElement('#activities-container');
		expect(await utils.isPresent('#activities-container')).to.be.true;

		await utils.waitForElement('#broadcasting-activity');
		await utils.clickOn('#broadcasting-activity');

		await browser.sleep(1000);

		const button = await utils.waitForElement('#broadcasting-btn');
		expect(await button.isEnabled()).to.be.false;

		const input = await utils.waitForElement('#broadcast-url-input');
		await input.sendKeys('BroadcastUrl');

		await utils.clickOn('#broadcasting-btn');

		// Checking if onActivitiesPanelStartBroadcastingClicked has been received
		await utils.waitForElement('#onActivitiesPanelStartBroadcastingClicked');
		expect(await utils.isPresent('#onActivitiesPanelStartBroadcastingClicked')).to.be.true;

		// TODO: it needs an OpenVidu PRO (onActivitiesPanelStopBroadcastingClicked event)

		// expect(await utils.isPresent('#broadcasting-tag')).to.be.true;

		// await utils.clickOn('#stop-broadcasting-btn');

		// // Checking if onActivitiesPanelStopBroadcastingClicked has been received
		// await utils.waitForElement('#onActivitiesPanelStopBroadcastingClicked');
		// expect(await utils.isPresent('#onActivitiesPanelStopBroadcastingClicked')).to.be.true;
		// expect(await utils.isPresent('#broadcasting-tag')).to.be.false;
	});

	it('should receive the onSessionCreated event', async () => {
		await browser.get(`${url}&prejoin=false`);

		await utils.checkSessionIsPresent();

		await utils.checkToolbarIsPresent();

		await utils.waitForElement('#onSessionCreated');
		expect(await utils.isPresent('#onSessionCreated')).to.be.true;

		expect(await utils.isPresent('#onJoinButtonClicked')).to.be.false;
	});

	// * PUBLISHER EVENTS

	it('should receive onParticipantCreated event from LOCAL participant', async () => {
		const participantName = 'TEST_USER';
		await browser.get(`${url}&participantName=${participantName}`);
		await utils.waitForElement(`#${participantName}-onParticipantCreated`);
		expect(await utils.isPresent(`#${participantName}-onParticipantCreated`)).to.be.true;
	});

	// * SESSION EVENTS

	it('should receive connectionCreated event from LOCAL participant', async () => {
		const participantName = 'TEST_USER';
		await browser.get(`${url}&prejoin=false&participantName=${participantName}`);

		await utils.waitForElement(`#${participantName}-connectionCreated`);
		expect(await utils.isPresent(`#${participantName}-connectionCreated`)).to.be.true;
	});

	it('should receive sessionDisconnected event from LOCAL participant', async () => {
		const participantName = 'TEST_USER';
		let element;
		await browser.get(`${url}&prejoin=false&participantName=${participantName}`);

		await utils.checkSessionIsPresent();

		await utils.checkToolbarIsPresent();

		// Checking if leave button is not present
		element = await utils.waitForElement('#leave-btn');
		await element.click();

		await utils.waitForElement(`#${participantName}-sessionDisconnected`);
		expect(await utils.isPresent(`#${participantName}-sessionDisconnected`)).to.be.true;
	});
});

describe('Testing replace track with emulated devices', () => {
	let browser: WebDriver;
	let utils: OpenViduComponentsPO;
	async function createChromeBrowser(): Promise<WebDriver> {
		return await new Builder()
			.forBrowser(WebComponentConfig.browserName)
			.withCapabilities(WebComponentConfig.browserCapabilities)
			.setChromeOptions(WebComponentConfig.browserOptions)
			.usingServer(WebComponentConfig.seleniumAddress)
			.build();
	}

	beforeEach(async () => {
		browser = await createChromeBrowser();
		utils = new OpenViduComponentsPO(browser);
	});

	afterEach(async () => {
		// console.log('data:image/png;base64,' + await browser.takeScreenshot());
		await browser.quit();
	});

	it('should replace the video track in prejoin page', async () => {
		const script = 'return document.getElementsByTagName("video")[0].srcObject.getVideoTracks()[0].label;';

		await browser.get(`${url}&fakeDevices=true`);

		let videoDevices = await utils.waitForElement('#video-devices-form');

		await videoDevices.click();

		let element = await utils.waitForElement('#option-custom_fake_video_1');

		await element.click();

		let videoLabel;

		await browser.sleep(1000);
		videoLabel = await browser.executeScript<string>(script);
		expect(videoLabel).to.be.equal('custom_fake_video_1');

		await videoDevices.click();

		element = await utils.waitForElement('#option-fake_device_0');
		await element.click();

		await browser.sleep(1000);
		videoLabel = await browser.executeScript<string>(script);
		expect(videoLabel).to.be.equal('fake_device_0');
	});

	it('should replace the video track in videoconference page', async () => {
		const script = 'return document.getElementsByTagName("video")[0].srcObject.getVideoTracks()[0].label;';

		await browser.get(`${url}&prejoin=false&fakeDevices=true`);

		await utils.checkSessionIsPresent();

		// Checking if toolbar is present
		await utils.checkToolbarIsPresent();

		// Open more options menu
		await utils.clickOn('#more-options-btn');

		// Checking if button panel is present
		await utils.waitForElement('.mat-menu-content');
		expect(await utils.isPresent('.mat-menu-content')).to.be.true;

		await utils.clickOn('#toolbar-settings-btn');

		await utils.waitForElement('.settings-container');
		expect(await utils.isPresent('.settings-container')).to.be.true;

		await utils.clickOn('#video-opt');
		expect(await utils.isPresent('ov-video-devices-select')).to.be.true;

		let videoDevices = await utils.waitForElement('#video-devices-form');

		await videoDevices.click();

		let element = await utils.waitForElement('#option-custom_fake_video_1');

		await element.click();

		let videoLabel;
		await browser.sleep(1000);
		videoLabel = await browser.executeScript<string>(script);
		expect(videoLabel).to.be.equal('custom_fake_video_1');

		await videoDevices.click();

		element = await utils.waitForElement('#option-fake_device_0');
		await element.click();

		await browser.sleep(1000);
		videoLabel = await browser.executeScript<string>(script);
		expect(videoLabel).to.be.equal('fake_device_0');
	});

	it('should replace the screen track', async () => {
		const script = 'return document.getElementsByClassName("OT_video-element screen-type")[0].srcObject.getVideoTracks()[0].label;';

		await browser.get(`${url}&prejoin=false&fakeDevices=true`);

		await utils.checkLayoutPresent();
		await utils.checkToolbarIsPresent();

		await utils.clickOn('#screenshare-btn');

		await browser.sleep(500);

		let screenLabel = await browser.executeScript<string>(script);
		expect(screenLabel).not.equal('custom_fake_screen');

		await utils.clickOn('#video-settings-btn-SCREEN');
		await browser.sleep(500);

		await utils.waitForElement('.video-settings-menu');
		const replaceBtn = await utils.waitForElement('#replace-screen-button');
		await replaceBtn.sendKeys(Key.ENTER);

		await browser.sleep(1000);
		screenLabel = await browser.executeScript<string>(script);
		expect(screenLabel).to.be.equal('custom_fake_screen');
	});
});

describe('Testing stream video menu features', () => {
	let browser: WebDriver;
	let utils: OpenViduComponentsPO;
	async function createChromeBrowser(): Promise<WebDriver> {
		return await new Builder()
			.forBrowser(WebComponentConfig.browserName)
			.withCapabilities(WebComponentConfig.browserCapabilities)
			.setChromeOptions(WebComponentConfig.browserOptions)
			.usingServer(WebComponentConfig.seleniumAddress)
			.build();
	}

	beforeEach(async () => {
		browser = await createChromeBrowser();
		utils = new OpenViduComponentsPO(browser);
	});

	afterEach(async () => {
		await browser.quit();
	});

	it('should not show the Mute sound button for local participant', async () => {
		await browser.get(`${url}&prejoin=false`);

		await utils.checkLayoutPresent();

		await utils.waitForElement('#video-settings-btn-CAMERA');
		await utils.clickOn('#video-settings-btn-CAMERA');

		await browser.sleep(500);

		// Checking if mute sound button is not present
		expect(await utils.isPresent('#sound-btn')).to.be.false;
	});
});

describe('Testing screenshare features', () => {
	let browser: WebDriver;
	let utils: OpenViduComponentsPO;
	async function createChromeBrowser(): Promise<WebDriver> {
		return await new Builder()
			.forBrowser(WebComponentConfig.browserName)
			.withCapabilities(WebComponentConfig.browserCapabilities)
			.setChromeOptions(WebComponentConfig.browserOptions)
			.usingServer(WebComponentConfig.seleniumAddress)
			.build();
	}

	beforeEach(async () => {
		browser = await createChromeBrowser();
		utils = new OpenViduComponentsPO(browser);
	});

	afterEach(async () => {
		await browser.quit();
	});



	it('should toggle screensharing twice', async () => {
		await browser.get(`${url}&prejoin=false`);
		await utils.checkLayoutPresent();

		// Clicking to screensharing button
		const screenshareButton = await utils.waitForElement('#screenshare-btn');
		expect(await screenshareButton.isDisplayed()).to.be.true;
		await screenshareButton.click();

		await utils.waitForElement('.OV_big');
		expect(await utils.getNumberOfElements('video')).equals(2);


		// Clicking to screensharing button
		await screenshareButton.click();
		expect(await utils.getNumberOfElements('video')).equals(1);


		// toggle screenshare again
		await screenshareButton.click();

		await utils.waitForElement('.OV_big');
		expect(await utils.getNumberOfElements('video')).equals(2);

		await screenshareButton.click();

		expect(await utils.getNumberOfElements('video')).equals(1);

	});

	it('should show only screen if toggle screensharing with video muted', async () => {
		await browser.get(`${url}&prejoin=false`);

		await utils.checkLayoutPresent();

		const camButton = await utils.waitForElement('#camera-btn');
		await camButton.click();

		// Clicking to screensharing button
		const screenshareButton = await utils.waitForElement('#screenshare-btn');
		expect(await screenshareButton.isDisplayed()).to.be.true;
		await screenshareButton.click();

		await browser.sleep(1000);
		await utils.waitForElement('.OV_big');

		expect(await utils.getNumberOfElements('video')).equals(1);


		await screenshareButton.click();
		await browser.sleep(1000);

		expect(await utils.getNumberOfElements('video')).equals(1);

	});

	it('should screensharing with audio muted', async () => {
		let isAudioEnabled;
		const getAudioScript = (className: string) => {
			return `return document.getElementsByClassName('${className}')[0].srcObject.getAudioTracks()[0].enabled;`;
		};
		await browser.get(`${url}&prejoin=false`);

		await utils.checkLayoutPresent();

		const micButton = await utils.waitForElement('#mic-btn');
		await micButton.click();

		// Clicking to screensharing button
		const screenshareButton = await utils.waitForElement('#screenshare-btn');
		expect(await utils.isPresent('#screenshare-btn')).to.be.true;
		await screenshareButton.click();

		await utils.waitForElement('.screen-type');
		expect(await utils.getNumberOfElements('video')).equals(2);


		isAudioEnabled = await browser.executeScript(getAudioScript('screen-type'));
		expect(isAudioEnabled).to.be.false;

		await utils.waitForElement('#statusMic');
		expect(await utils.getNumberOfElements('#statusMic')).equals(2);

		// Clicking to screensharing button
		await screenshareButton.click();
		expect(await utils.getNumberOfElements('video')).equals(1);

	});

	it('should show and hide CAMERA stream when muting video with screensharing', async () => {
		await browser.get(`${url}&prejoin=false`);

		await utils.checkLayoutPresent();

		// Clicking to screensharing button
		const screenshareButton = await utils.waitForElement('#screenshare-btn');
		expect(await screenshareButton.isDisplayed()).to.be.true;
		await screenshareButton.click();

		await utils.waitForElement('.OV_big');
		expect(await utils.getNumberOfElements('video')).equals(2);

		const muteVideoButton = await utils.waitForElement('#camera-btn');
		await muteVideoButton.click();

		expect(await utils.getNumberOfElements('video')).equals(1);
	});

	it('should screenshare has audio active when camera is muted', async () => {
		let isAudioEnabled;
		const audioEnableScript = 'return document.getElementsByTagName("video")[0].srcObject.getAudioTracks()[0].enabled;';

		await browser.get(`${url}&prejoin=false`);

		await utils.checkLayoutPresent();

		// Clicking to screensharing button
		const screenshareButton = await utils.waitForElement('#screenshare-btn');
		expect(await utils.isPresent('#screenshare-btn')).to.be.true;
		await screenshareButton.click();

		await utils.waitForElement('.OV_big');
		expect(await utils.getNumberOfElements('video')).equals(2);
		expect(await utils.getNumberOfElements('#statusMic')).equals(1);

		// Muting camera video
		const muteVideoButton = await utils.waitForElement('#camera-btn');
		await muteVideoButton.click();

		expect(await utils.getNumberOfElements('video')).equals(1);

		await browser.sleep(500);
		expect(await utils.isPresent('#statusMic')).to.be.false;

		// Checking if audio is muted after join the room
		isAudioEnabled = await browser.executeScript(audioEnableScript);
		expect(isAudioEnabled).to.be.true;

		// Unmuting camera
		await muteVideoButton.click();
		await browser.sleep(1000);

		await utils.waitForElement('.camera-type');
		expect(await utils.getNumberOfElements('video')).equals(2);
		expect(await utils.getNumberOfElements('#statusMic')).equals(1);
	});

	it('should camera come back with audio muted when screensharing', async () => {
		let element, isAudioEnabled;

		const getAudioScript = (className: string) => {
			return `return document.getElementsByClassName('${className}')[0].srcObject.getAudioTracks()[0].enabled;`;
		};

		await browser.get(`${url}&prejoin=false`);

		await utils.checkLayoutPresent();

		// Clicking to screensharing button
		const screenshareButton = await utils.waitForElement('#screenshare-btn');
		await screenshareButton.click();

		await utils.waitForElement('.screen-type');
		expect(await utils.getNumberOfElements('video')).equals(2);
		expect(await utils.getNumberOfElements('#statusMic')).equals(1);


		// Mute camera
		const muteVideoButton = await utils.waitForElement('#camera-btn');
		await muteVideoButton.click();


		expect(await utils.getNumberOfElements('video')).equals(1);
		expect(await utils.isPresent('#statusMic')).to.be.false;

		// Checking if audio is muted after join the room
		isAudioEnabled = await browser.executeScript(getAudioScript('screen-type'));
		expect(isAudioEnabled).to.be.true;

		// Mute audio
		const muteAudioButton = await utils.waitForElement('#mic-btn');
		await muteAudioButton.click();

		await utils.waitForElement('#statusMic');
		expect(await utils.getNumberOfElements('#statusMic')).equals(1);


		isAudioEnabled = await browser.executeScript(getAudioScript('screen-type'));
		expect(isAudioEnabled).to.be.false;

		// Unmute camera
		await muteVideoButton.click();

		await utils.waitForElement('.camera-type');
		expect(await utils.getNumberOfElements('video')).equals(2);
		expect(await utils.getNumberOfElements('#statusMic')).equals(2);


		isAudioEnabled = await browser.executeScript(getAudioScript('camera-type'));
		expect(isAudioEnabled).to.be.false;
	});
});

describe('Testing panels', () => {
	let browser: WebDriver;
	let utils: OpenViduComponentsPO;

	async function createChromeBrowser(): Promise<WebDriver> {
		return await new Builder()
			.forBrowser(WebComponentConfig.browserName)
			.withCapabilities(WebComponentConfig.browserCapabilities)
			.setChromeOptions(WebComponentConfig.browserOptions)
			.usingServer(WebComponentConfig.seleniumAddress)
			.build();
	}

	beforeEach(async () => {
		browser = await createChromeBrowser();
		utils = new OpenViduComponentsPO(browser);
	});

	afterEach(async () => {
		await browser.quit();
	});

	/**
	 * TODO
	 * It only works with OpenVidu PRO because this is a PRO feature
	 */
	// it('should toggle BACKGROUND panel on prejoin page when VIDEO is MUTED', async () => {
	// 	let element;
	// 	await browser.get(`${url}`);
	// 	element = await utils.waitForElement('#pre-join-container');
	// 	expect(await utils.isPresent('#pre-join-container')).to.be.true;

	// 	const backgroundButton = await utils.waitForElement('#background-effects-btn');
	// 	expect(await utils.isPresent('#background-effects-btn')).to.be.true;
	// 	expect(await backgroundButton.isEnabled()).to.be.true;
	// 	await backgroundButton.click();
	// 	await browser.sleep(500);

	// 	await utils.waitForElement('#background-effects-container');
	// 	expect(await utils.isPresent('#background-effects-container')).to.be.true;

	// 	element = await utils.waitForElement('#camera-button');
	// 	expect(await utils.isPresent('#camera-button')).to.be.true;
	// 	expect(await element.isEnabled()).to.be.true;
	// 	await element.click();

	// 	await browser.sleep(500);
	// 	element = await utils.waitForElement('#video-poster');
	// 	expect(await utils.isPresent('#video-poster')).to.be.true;

	// 	expect(await backgroundButton.isDisplayed()).to.be.true;
	// 	expect(await backgroundButton.isEnabled()).to.be.false;

	// 	expect(await utils.isPresent('#background-effects-container')).to.be.false;
	// });

	it('should toggle CHAT panel', async () => {
		await browser.get(`${url}&prejoin=false`);

		await utils.checkLayoutPresent();

		const chatButton = await utils.waitForElement('#chat-panel-btn');
		await chatButton.click();

		await utils.waitForElement('.sidenav-menu');
		await utils.waitForElement('.input-container');
		expect(await utils.isPresent('.input-container')).to.be.true;

		await utils.waitForElement('.messages-container');
		expect(await utils.isPresent('.messages-container')).to.be.true;

		await chatButton.click();

		expect(await utils.isPresent('.input-container')).to.be.false;
		expect(await utils.isPresent('.messages-container')).to.be.false;
	});

	it('should toggle PARTICIPANTS panel', async () => {
		await browser.get(`${url}&prejoin=false`);

		await utils.checkLayoutPresent();

		const participantBtn = await utils.waitForElement('#participants-panel-btn');
		await participantBtn.click();

		await utils.waitForElement('.sidenav-menu');

		await utils.waitForElement('.local-participant-container');
		expect(await utils.isPresent('.local-participant-container')).to.be.true;

		await utils.waitForElement('ov-participant-panel-item');
		expect(await utils.isPresent('ov-participant-panel-item')).to.be.true;

		await participantBtn.click();

		expect(await utils.isPresent('.local-participant-container')).to.be.false;
		expect(await utils.isPresent('ov-participant-panel-item')).to.be.false;
	});

	it('should toggle ACTIVITIES panel', async () => {
		await browser.get(`${url}&prejoin=false`);

		await utils.checkLayoutPresent();

		// Get activities button and click into it
		const activitiesBtn = await utils.waitForElement('#activities-panel-btn');
		await activitiesBtn.click();

		await utils.waitForElement('.sidenav-menu');
		await utils.waitForElement('#activities-container');
		expect(await utils.isPresent('#activities-container')).to.be.true;

		await utils.waitForElement('#recording-activity');
		expect(await utils.isPresent('#recording-activity')).to.be.true;
		await activitiesBtn.click();

		expect(await utils.isPresent('#activities-container')).to.be.false;
		expect(await utils.isPresent('#recording-activity')).to.be.false;
	});

	it('should toggle SETTINGS panel', async () => {
		let element;
		await browser.get(`${url}&prejoin=false`);

		await utils.checkLayoutPresent();

		// Checking if toolbar is present
		await utils.checkToolbarIsPresent();

		// Open more options menu
		element = await utils.waitForElement('#more-options-btn');
		await element.click();

		await browser.sleep(500);

		// Checking if mat menu is  present
		element = await utils.waitForElement('.mat-menu-content');
		expect(await utils.isPresent('.mat-menu-content')).to.be.true;

		// Get settings button and click into it
		const settingsBtn = await utils.waitForElement('#toolbar-settings-btn');
		await settingsBtn.click();

		element = await utils.waitForElement('.sidenav-menu');
		expect(await utils.isPresent('#default-settings-panel')).to.be.true;
	});

	it('should switching between PARTICIPANTS and CHAT panels', async () => {
		await browser.get(`${url}&prejoin=false`);

		await utils.checkSessionIsPresent();

		await utils.checkToolbarIsPresent();

		// Open chat panel
		const chatButton = await utils.waitForElement('#chat-panel-btn');
		await chatButton.click();

		await utils.waitForElement('.sidenav-menu');
		expect(await utils.isPresent('.sidenav-menu')).to.be.true;

		await utils.waitForElement('.input-container');
		expect(await utils.isPresent('.input-container')).to.be.true;

		expect(await utils.isPresent('.messages-container')).to.be.true;

		// Open participants panel
		const participantBtn = await utils.waitForElement('#participants-panel-btn');
		await participantBtn.click();

		await utils.waitForElement('.sidenav-menu');

		expect(await utils.isPresent('.local-participant-container')).to.be.true;

		expect(await utils.isPresent('ov-participant-panel-item')).to.be.true;

		// Switch to chat panel
		await chatButton.click();

		await utils.waitForElement('.sidenav-menu');

		expect(await utils.isPresent('.input-container')).to.be.true;

		expect(await utils.isPresent('.messages-container')).to.be.true;

		expect(await utils.isPresent('.local-participant-container')).to.be.false;

		expect(await utils.isPresent('ov-participant-panel-item')).to.be.false;

		// Close chat panel
		await chatButton.click();
		expect(await utils.getNumberOfElements('.input-container')).equals(0);
		expect(await utils.isPresent('messages-container')).to.be.false;
	});

	it('should switching between sections in SETTINGS PANEL', async () => {
		let element;
		await browser.get(`${url}&prejoin=false`);

		await utils.checkToolbarIsPresent();

		// Checking if toolbar is present
		await utils.checkToolbarIsPresent();

		// Open more options menu
		element = await utils.waitForElement('#more-options-btn');
		await element.click();

		await browser.sleep(500);

		// Checking if mat menu is  present
		await utils.waitForElement('.mat-menu-content');
		expect(await utils.isPresent('.mat-menu-content')).to.be.true;

		// Get settings button and click into it
		const settingsBtn = await utils.waitForElement('#toolbar-settings-btn');
		await settingsBtn.click();

		await utils.waitForElement('.sidenav-menu');
		expect(await utils.isPresent('.sidenav-menu')).to.be.true;

		// Check if general section is shown
		element = await utils.waitForElement('#general-opt');
		await element.click();

		expect(await utils.isPresent('ov-nickname-input')).to.be.true;

		// Check if video section is shown
		element = await utils.waitForElement('#video-opt');
		await element.click();

		expect(await utils.isPresent('ov-video-devices-select')).to.be.true;

		// Check if audio section is shown
		element = await utils.waitForElement('#audio-opt');
		await element.click();

		expect(await utils.isPresent('ov-audio-devices-select')).to.be.true;
	});
});

describe('Testing CHAT features', () => {
	let browser: WebDriver;
	let utils: OpenViduComponentsPO;

	async function createChromeBrowser(): Promise<WebDriver> {
		return await new Builder()
			.forBrowser(WebComponentConfig.browserName)
			.withCapabilities(WebComponentConfig.browserCapabilities)
			.setChromeOptions(WebComponentConfig.browserOptions)
			.usingServer(WebComponentConfig.seleniumAddress)
			.build();
	}

	beforeEach(async () => {
		browser = await createChromeBrowser();
		utils = new OpenViduComponentsPO(browser);
	});

	afterEach(async () => {
		await browser.quit();
	});

	it('should send an url message and converts in a link', async () => {
		await browser.get(`${url}&prejoin=false`);

		await utils.checkLayoutPresent();

		const chatButton = await utils.waitForElement('#chat-panel-btn');
		await chatButton.click();

		await utils.waitForElement('.sidenav-menu');
		await utils.waitForElement('.input-container');
		expect(await utils.isPresent('.input-container')).to.be.true;

		const input = await utils.waitForElement('#chat-input');
		await input.sendKeys('demos.openvidu.io');

		await utils.clickOn('#send-btn');

		await utils.waitForElement('.msg-content a');
		expect(await utils.isPresent('.msg-content a')).to.be.true;
	});
});

describe('Testing TOOLBAR features', () => {
	let browser: WebDriver;
	let utils: OpenViduComponentsPO;
	async function createChromeBrowser(): Promise<WebDriver> {
		return await new Builder()
			.forBrowser(WebComponentConfig.browserName)
			.withCapabilities(WebComponentConfig.browserCapabilities)
			.setChromeOptions(WebComponentConfig.browserOptions)
			.usingServer(WebComponentConfig.seleniumAddress)
			.build();
	}

	beforeEach(async () => {
		browser = await createChromeBrowser();
		utils = new OpenViduComponentsPO(browser);
	});

	afterEach(async () => {
		await browser.quit();
	});

	it('should mute and unmute the local microphone', async () => {
		await browser.get(`${url}&prejoin=false`);

		await utils.checkLayoutPresent();

		const micButton = await utils.waitForElement('#mic-btn');
		await micButton.click();

		await utils.waitForElement('#mic-btn #mic_off');
		expect(await utils.isPresent('#mic-btn #mic_off')).to.be.true;

		await micButton.click();

		await utils.waitForElement('#mic-btn #mic');
		expect(await utils.isPresent('#mic-btn #mic')).to.be.true;
	});

	it('should mute and unmute the local camera', async () => {
		await browser.get(`${url}&prejoin=false`);

		await utils.checkLayoutPresent();

		const cameraButton = await utils.waitForElement('#camera-btn');
		await cameraButton.click();

		await utils.waitForElement('#camera-btn #videocam_off');
		expect(await utils.isPresent('#camera-btn #videocam_off')).to.be.true;

		await cameraButton.click();

		await utils.waitForElement('#camera-btn #videocam');
		expect(await utils.isPresent('#camera-btn #videocam')).to.be.true;
	});
});


describe('Testing video is playing', () => {
	let browser: WebDriver;
	let utils: OpenViduComponentsPO;

	async function createChromeBrowser(): Promise<WebDriver> {
		return await new Builder()
			.forBrowser(WebComponentConfig.browserName)
			.withCapabilities(WebComponentConfig.browserCapabilities)
			.setChromeOptions(WebComponentConfig.browserOptions)
			.usingServer(WebComponentConfig.seleniumAddress)
			.build();
	}

	beforeEach(async () => {
		browser = await createChromeBrowser();
		utils = new OpenViduComponentsPO(browser);
	});

	afterEach(async () => {
		await browser.quit();
	});

	it('should play the participant video with only audio', async () => {
		const sessionName = 'audioOnlyE2E';
		const fixedUrl = `${url}&sessionName=${sessionName}`;
		await browser.get(fixedUrl);

		await utils.checkPrejoinIsPresent();
		await utils.clickOn('#join-button');

		// Starting new browser for adding the second participant
		const newTabScript = `window.open("${fixedUrl}")`;
		await browser.executeScript(newTabScript);
		const tabs = await browser.getAllWindowHandles();
		await browser.switchTo().window(tabs[1]);

		await utils.checkPrejoinIsPresent();
		await utils.clickOn('#camera-button');
		await utils.clickOn('#join-button');

		// Go to first tab
		await browser.switchTo().window(tabs[0]);

		// Wait until NO_STREAM_PLAYING_EVENT exception timeout is reached
		await browser.sleep(6000);

		const exceptionQuantity = await utils.getNumberOfElements('#NO_STREAM_PLAYING_EVENT');
		expect(exceptionQuantity).equals(0);
	});

	it('should play the participant video with only video', async () => {
		const sessionName = 'videoOnlyE2E';
		const fixedUrl = `${url}&sessionName=${sessionName}`;
		await browser.get(fixedUrl);

		await utils.checkPrejoinIsPresent();
		await utils.clickOn('#join-button');

		// Starting new browser for adding the second participant
		const newTabScript = `window.open("${fixedUrl}")`;
		await browser.executeScript(newTabScript);
		const tabs = await browser.getAllWindowHandles();
		await browser.switchTo().window(tabs[1]);

		await utils.checkPrejoinIsPresent();
		await utils.clickOn('#microphone-button');
		await utils.clickOn('#join-button');

		// Go to first tab
		await browser.switchTo().window(tabs[0]);

		// Wait until NO_STREAM_PLAYING_EVENT exception timeout is reached
		await browser.sleep(6000);

		const exceptionQuantity = await utils.getNumberOfElements('#NO_STREAM_PLAYING_EVENT');
		expect(exceptionQuantity).equals(0);
	});
});

describe('Testing WITHOUT MEDIA DEVICES permissions', () => {
	let browser: WebDriver;
	let utils: OpenViduComponentsPO;
	async function createChromeBrowser(): Promise<WebDriver> {
		return await new Builder()
			.forBrowser(WebComponentConfig.browserName)
			.withCapabilities(WebComponentConfig.browserCapabilities)
			.setChromeOptions(getBrowserOptionsWithoutDevices())
			.usingServer(WebComponentConfig.seleniumAddress)
			.build();
	}

	beforeEach(async () => {
		browser = await createChromeBrowser();
		utils = new OpenViduComponentsPO(browser);
	});

	afterEach(async () => {
		await browser.quit();
	});

	it('should be able to ACCESS to PREJOIN page', async () => {
		await browser.get(`${url}`);

		await utils.checkPrejoinIsPresent();

		let button = await utils.waitForElement('#camera-button');
		expect(await button.isEnabled()).to.be.false;

		button = await utils.waitForElement('#microphone-button');
		expect(await button.isEnabled()).to.be.false;
	});

	it('should be able to ACCESS to ROOM page', async () => {
		await browser.get(`${url}`);

		await utils.checkPrejoinIsPresent();

		await utils.clickOn('#join-button');

		await utils.checkSessionIsPresent();

		await utils.checkToolbarIsPresent();

		let button = await utils.waitForElement('#camera-btn');
		expect(await button.isEnabled()).to.be.false;

		button = await utils.waitForElement('#mic-btn');
		expect(await button.isEnabled()).to.be.false;
	});

	it('should be able to ACCESS to ROOM page without prejoin', async () => {
		await browser.get(`${url}&prejoin=false`);

		await utils.checkSessionIsPresent();

		await utils.checkToolbarIsPresent();

		let button = await utils.waitForElement('#camera-btn');
		expect(await button.isEnabled()).to.be.false;

		button = await utils.waitForElement('#mic-btn');
		expect(await button.isEnabled()).to.be.false;
	});

	it('should the settings buttons be disabled', async () => {
		await browser.get(`${url}&prejoin=false`);

		await utils.checkToolbarIsPresent();

		// Open more options menu
		await utils.clickOn('#more-options-btn');

		await browser.sleep(500);

		// Checking if fullscreen button is not present
		await utils.waitForElement('.mat-menu-content');
		expect(await utils.isPresent('.mat-menu-content')).to.be.true;

		await utils.clickOn('#toolbar-settings-btn');

		await browser.sleep(500);

		await utils.waitForElement('.settings-container');
		expect(await utils.isPresent('.settings-container')).to.be.true;

		await utils.clickOn('#video-opt');
		expect(await utils.isPresent('ov-video-devices-select')).to.be.true;

		let button = await utils.waitForElement('#camera-button');
		expect(await button.isEnabled()).to.be.false;

		await utils.clickOn('#audio-opt');
		expect(await utils.isPresent('ov-audio-devices-select')).to.be.true;

		button = await utils.waitForElement('#microphone-button');
		expect(await button.isEnabled()).to.be.false;

	});
});

describe('Testing PRO features with OpenVidu CE', () => {
	let browser: WebDriver;
	let utils: OpenViduComponentsPO;
	async function createChromeBrowser(): Promise<WebDriver> {
		return await new Builder()
			.forBrowser(WebComponentConfig.browserName)
			.withCapabilities(WebComponentConfig.browserCapabilities)
			.setChromeOptions(WebComponentConfig.browserOptions)
			.usingServer(WebComponentConfig.seleniumAddress)
			.build();
	}

	beforeEach(async () => {
		browser = await createChromeBrowser();
		utils = new OpenViduComponentsPO(browser);
	});

	afterEach(async () => {
		await browser.quit();
	});

	it('should SHOW the VIRTUAL BACKGROUND PRO feature dialog', async () => {
		await browser.get(`${url}&prejoin=true`);

		await utils.checkPrejoinIsPresent();

		await utils.waitForElement('#background-effects-btn');
		await utils.clickOn('#background-effects-btn');

		await utils.chceckProFeatureAlertIsPresent();

		// Close alert
		await (await utils.waitForElement('html')).sendKeys(Key.ESCAPE);

		// Join to room
		await utils.clickOn('#join-button');

		await utils.checkSessionIsPresent();

		// Checking if toolbar is present
		await utils.checkToolbarIsPresent();

		// Open more options menu
		await utils.clickOn('#more-options-btn');

		await browser.sleep(500);

		// Checking if button panel is present
		await utils.waitForElement('.mat-menu-content');
		expect(await utils.isPresent('.mat-menu-content')).to.be.true;

		await utils.waitForElement('#virtual-bg-btn');
		await utils.clickOn('#virtual-bg-btn');

		// Expect it shows the pro feature alert
		await utils.chceckProFeatureAlertIsPresent();
	});

	it('should SHOW the CAPTIONS PRO feature dialog', async () => {
		await browser.get(`${url}&prejoin=false`);

		await utils.checkSessionIsPresent();

		// Checking if toolbar is present
		await utils.checkToolbarIsPresent();

		// Open more options menu
		await utils.clickOn('#more-options-btn');

		await browser.sleep(500);

		// Checking if button panel is present
		await utils.waitForElement('.mat-menu-content');
		expect(await utils.isPresent('.mat-menu-content')).to.be.true;

		await utils.waitForElement('#toolbar-settings-btn');
		expect(await utils.isPresent('#toolbar-settings-btn')).to.be.true;
		await utils.clickOn('#toolbar-settings-btn');

		// Expect captions panel shows the pro feature content
		await utils.waitForElement('#settings-container');
		await utils.clickOn('#captions-opt');
		await browser.sleep(1000);
		await utils.waitForElement('.pro-feature');

		// Open more options menu
		await utils.clickOn('#more-options-btn');

		await browser.sleep(500);

		// Checking if button panel is present
		await utils.waitForElement('.mat-menu-content');
		expect(await utils.isPresent('.mat-menu-content')).to.be.true;

		// Checking if captions button is present
		await utils.waitForElement('#captions-btn');
		expect(await utils.isPresent('#captions-btn')).to.be.true;
		await utils.clickOn('#captions-btn');

		await utils.waitForElement('ov-pro-feature-template');
		expect(await utils.isPresent('.captions-container')).to.be.false;
	});
});

/**
 * TODO:
 *  The following E2E TESTS only work with OpenVidu PRO.
 * It should run with OpenVidu PRO
 */
// describe('Testing captions features', () => {
// 	let browser: WebDriver;
// 	let utils: OpenViduComponentsPO;
// 	async function createChromeBrowser(): Promise<WebDriver> {
// 		return await new Builder()
// 			.forBrowser(WebComponentConfig.browserName)
// 			.withCapabilities(WebComponentConfig.browserCapabilities)
// 			.setChromeOptions(WebComponentConfig.browserOptions)
// 			.usingServer(WebComponentConfig.seleniumAddress)
// 			.build();
// 	}

// 	beforeEach(async () => {
// 		browser = await createChromeBrowser();
// 		utils = new OpenViduComponentsPO(browser);
// 	});

// 	afterEach(async () => {
// 		await browser.quit();
// 	});

// 	it('should OPEN the CAPTIONS container', async () => {
// 		await browser.get(`${url}&prejoin=false`);

// 		await utils.checkSessionIsPresent();

// 		// Checking if toolbar is present
// 		await utils.checkToolbarIsPresent();

// 		// Open more options menu
// 		await utils.clickOn('#more-options-btn');

// 		await browser.sleep(500);

// 		// Checking if button panel is present
// 		await utils.waitForElement('.mat-menu-content');
// 		expect(await utils.isPresent('.mat-menu-content')).to.be.true;

// 		// Checking if captions button is present
// 		await utils.waitForElement('#captions-btn');
// 		expect(await utils.isPresent('#captions-btn')).to.be.true;
// 		await utils.clickOn('#captions-btn');

// 		await utils.waitForElement('.captions-container');
// 	});

// 	it('should OPEN the SETTINGS panel from captions button', async () => {
// 		await browser.get(`${url}&prejoin=false`);

// 		await utils.checkSessionIsPresent();

// 		// Checking if toolbar is present
// 		await utils.checkToolbarIsPresent();

// 		// Open more options menu
// 		await utils.clickOn('#more-options-btn');

// 		await browser.sleep(500);

// 		// Checking if button panel is present
// 		await utils.waitForElement('.mat-menu-content');
// 		expect(await utils.isPresent('.mat-menu-content')).to.be.true;

// 		// Checking if captions button is present
// 		await utils.waitForElement('#captions-btn');
// 		expect(await utils.isPresent('#captions-btn')).to.be.true;
// 		await utils.clickOn('#captions-btn');

// 		await utils.waitForElement('.captions-container');
// 		await utils.waitForElement('#caption-settings-btn');
// 		await utils.clickOn('#caption-settings-btn');

// 		await browser.sleep(500);

// 		await utils.waitForElement('.settings-container');
// 		expect(await utils.isPresent('.settings-container')).to.be.true;

// 		await utils.waitForElement('ov-captions-settings');

// 		// Expect caption button is not present
// 		expect(await utils.isPresent('#caption-settings-btn')).to.be.false;
// 	});

// 	it('should TOGGLE the CAPTIONS container from settings panel', async () => {
// 		await browser.get(`${url}&prejoin=false`);

// 		await utils.checkSessionIsPresent();

// 		// Checking if toolbar is present
// 		await utils.checkToolbarIsPresent();

// 		// Open more options menu
// 		await utils.clickOn('#more-options-btn');

// 		await browser.sleep(500);

// 		// Checking if button panel is present
// 		await utils.waitForElement('.mat-menu-content');
// 		expect(await utils.isPresent('.mat-menu-content')).to.be.true;

// 		// Checking if captions button is present
// 		await utils.waitForElement('#captions-btn');
// 		expect(await utils.isPresent('#captions-btn')).to.be.true;
// 		await utils.clickOn('#captions-btn');

// 		await utils.waitForElement('.captions-container');
// 		await utils.waitForElement('#caption-settings-btn');
// 		await utils.clickOn('#caption-settings-btn');

// 		await browser.sleep(500);

// 		await utils.waitForElement('.settings-container');
// 		expect(await utils.isPresent('.settings-container')).to.be.true;

// 		await utils.waitForElement('ov-captions-settings');

// 		expect(await utils.isPresent('.captions-container')).to.be.true;
// 		await utils.clickOn('#captions-toggle-slide');
// 		expect(await utils.isPresent('.captions-container')).to.be.false;

// 		await browser.sleep(200);

// 		await utils.clickOn('#captions-toggle-slide');
// 		expect(await utils.isPresent('.captions-container')).to.be.true;
// 	});

// 	it('should change the CAPTIONS language', async () => {
// 		await browser.get(`${url}&prejoin=false`);

// 		await utils.checkSessionIsPresent();

// 		// Checking if toolbar is present
// 		await utils.checkToolbarIsPresent();

// 		// Open more options menu
// 		await utils.clickOn('#more-options-btn');

// 		await browser.sleep(500);

// 		// Checking if button panel is present
// 		await utils.waitForElement('.mat-menu-content');
// 		expect(await utils.isPresent('.mat-menu-content')).to.be.true;

// 		// Checking if captions button is present
// 		await utils.waitForElement('#captions-btn');
// 		expect(await utils.isPresent('#captions-btn')).to.be.true;
// 		await utils.clickOn('#captions-btn');

// 		await utils.waitForElement('.captions-container');
// 		await utils.waitForElement('#caption-settings-btn');
// 		await utils.clickOn('#caption-settings-btn');

// 		await browser.sleep(500);

// 		await utils.waitForElement('.settings-container');
// 		expect(await utils.isPresent('.settings-container')).to.be.true;

// 		await utils.waitForElement('ov-captions-settings');

// 		expect(await utils.isPresent('.captions-container')).to.be.true;

// 		await utils.clickOn('.lang-button');
// 		await browser.sleep(500);

// 		await utils.clickOn('#es-ES');
// 		await utils.clickOn('.panel-close-button');

// 		const button = await utils.waitForElement('#caption-settings-btn');
// 		expect(await button.getText()).equals('settingsEspañol');

// 	});
// });

describe('Testing WITHOUT MEDIA DEVICES permissions', () => {
	let browser: WebDriver;
	let utils: OpenViduComponentsPO;
	async function createChromeBrowser(): Promise<WebDriver> {
		return await new Builder()
			.forBrowser(WebComponentConfig.browserName)
			.withCapabilities(WebComponentConfig.browserCapabilities)
			.setChromeOptions(getBrowserOptionsWithoutDevices())
			.usingServer(WebComponentConfig.seleniumAddress)
			.build();
	}

	beforeEach(async () => {
		browser = await createChromeBrowser();
		utils = new OpenViduComponentsPO(browser);
	});

	afterEach(async () => {
		await browser.quit();
	});

	it('should be able to ACCESS to PREJOIN page', async () => {
		await browser.get(`${url}`);

		await utils.checkPrejoinIsPresent();

		let button = await utils.waitForElement('#camera-button');
		expect(await button.isEnabled()).to.be.false;

		button = await utils.waitForElement('#microphone-button');
		expect(await button.isEnabled()).to.be.false;
	});

	it('should be able to ACCESS to ROOM page', async () => {
		await browser.get(`${url}`);

		await utils.checkPrejoinIsPresent();

		await utils.clickOn('#join-button');

		await utils.checkSessionIsPresent();

		await utils.checkToolbarIsPresent();

		let button = await utils.waitForElement('#camera-btn');
		expect(await button.isEnabled()).to.be.false;

		button = await utils.waitForElement('#mic-btn');
		expect(await button.isEnabled()).to.be.false;
	});

	it('should be able to ACCESS to ROOM page without prejoin', async () => {
		await browser.get(`${url}&prejoin=false`);

		await utils.checkSessionIsPresent();

		await utils.checkToolbarIsPresent();

		let button = await utils.waitForElement('#camera-btn');
		expect(await button.isEnabled()).to.be.false;

		button = await utils.waitForElement('#mic-btn');
		expect(await button.isEnabled()).to.be.false;
	});

	it('should the settings buttons be disabled', async () => {
		await browser.get(`${url}&prejoin=false`);

		await utils.checkToolbarIsPresent();

		// Open more options menu
		await utils.clickOn('#more-options-btn');

		await browser.sleep(500);

		// Checking if fullscreen button is not present
		await utils.waitForElement('.mat-menu-content');
		expect(await utils.isPresent('.mat-menu-content')).to.be.true;

		await utils.clickOn('#toolbar-settings-btn');

		await browser.sleep(500);

		await utils.waitForElement('.settings-container');
		expect(await utils.isPresent('.settings-container')).to.be.true;

		await utils.clickOn('#video-opt');
		expect(await utils.isPresent('ov-video-devices-select')).to.be.true;

		let button = await utils.waitForElement('#camera-button');
		expect(await button.isEnabled()).to.be.false;

		await utils.clickOn('#audio-opt');
		expect(await utils.isPresent('ov-audio-devices-select')).to.be.true;

		button = await utils.waitForElement('#microphone-button');
		expect(await button.isEnabled()).to.be.false;
	});
});