ambiser
/
openvidu
mirror of https://github.com/OpenVidu/openvidu.git
8
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

openvidu-test-e2e: update OpenViduEventManager to support user specific targets

pull/760/head
pabloFuente 2022-11-10 13:01:08 +01:00
parent 78cdd2442d
commit 3ad506e01a
2 changed files with 247 additions and 157 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

98
openvidu-test-e2e/src/main/java/io/openvidu/test/e2e/OpenViduEventManager.java
View File

@ -22,6 +22,7 @@ import static org.openqa.selenium.OutputType.BASE64;
import java.awt.Point;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
@ -82,9 +83,15 @@ public class OpenViduEventManager {
private ExecutorService execService = Executors.newCachedThreadPool();
private WebDriver driver;
private Queue<JsonObject> eventQueue;
private Map<String, Collection<RunnableCallback>> eventCallbacks;
private Map<String, AtomicInteger> eventNumbers;
private Map<String, CountDownLatch> eventCountdowns;
private Map<Integer, Map<String, Collection<RunnableCallback>>> eventCallbacksByUser;
private Map<Integer, Map<String, AtomicInteger>> eventNumbersByUser;
private Map<Integer, Map<String, CountDownLatch>> eventCountdownsByUser;
private AtomicBoolean isInterrupted = new AtomicBoolean(false);
private CountDownLatch pollingLatch = new CountDownLatch(1);
private int timeOfWaitInSeconds;
@ -95,6 +102,9 @@ public class OpenViduEventManager {
this.eventCallbacks = new ConcurrentHashMap<>();
this.eventNumbers = new ConcurrentHashMap<>();
this.eventCountdowns = new ConcurrentHashMap<>();
this.eventCallbacksByUser = new ConcurrentHashMap<>();
this.eventNumbersByUser = new ConcurrentHashMap<>();
this.eventCountdownsByUser = new ConcurrentHashMap<>();
this.timeOfWaitInSeconds = timeOfWaitInSeconds;
}
@ -148,6 +158,9 @@ public class OpenViduEventManager {
this.eventCallbacks.clear();
this.eventCountdowns.clear();
this.eventNumbers.clear();
this.eventCallbacksByUser.clear();
this.eventCountdownsByUser.clear();
this.eventNumbersByUser.clear();
}
}
@ -156,10 +169,25 @@ public class OpenViduEventManager {
this.eventCallbacks.get(eventName).add(new RunnableCallback(callback));
}
public void on(int numberOfUser, String eventName, Consumer<JsonObject> callback) {
this.eventCallbacksByUser.putIfAbsent(numberOfUser, new HashMap<>());
this.eventCallbacksByUser.get(numberOfUser).putIfAbsent(eventName, new HashSet<>());
this.eventCallbacksByUser.get(numberOfUser).get(eventName).add(new RunnableCallback(callback));
}
public void off(String eventName) {
this.eventCallbacks.remove(eventName);
}
public void off(int numberOfUser, String eventName) {
if (this.eventCallbacksByUser.containsKey(numberOfUser)) {
this.eventCallbacksByUser.get(numberOfUser).remove(eventName);
if (this.eventCallbacksByUser.get(numberOfUser).isEmpty()) {
this.eventCallbacksByUser.remove(numberOfUser);
}
}
}
// 'eventNumber' is accumulative for event 'eventName' for one page while it is
// not refreshed
public void waitUntilEventReaches(String eventName, int eventNumber) throws Exception {
@ -187,18 +215,58 @@ public class OpenViduEventManager {
}
}
public void waitUntilEventReaches(int numberOfUser, String eventName, int eventNumber) throws Exception {
this.waitUntilEventReaches(numberOfUser, eventName, eventNumber, this.timeOfWaitInSeconds, true);
}
public void waitUntilEventReaches(int numberOfUser, String eventName, int eventNumber, int secondsOfWait, boolean printTimeoutError)
throws Exception {
CountDownLatch eventSignal = new CountDownLatch(eventNumber);
this.setCountDown(numberOfUser, eventName, eventSignal);
try {
if (!eventSignal.await(secondsOfWait * 1000, TimeUnit.MILLISECONDS)) {
if (printTimeoutError) {
String screenshot = "data:image/png;base64," + ((TakesScreenshot) driver).getScreenshotAs(BASE64);
System.out.println("TIMEOUT SCREENSHOT");
System.out.println(screenshot);
}
throw (new TimeoutException());
}
} catch (InterruptedException | TimeoutException e) {
if (printTimeoutError) {
e.printStackTrace();
}
throw e;
}
}
// Sets any event count to 0
public synchronized void clearCurrentEvents(String eventName) {
this.eventNumbers.put(eventName, new AtomicInteger(0));
this.setCountDown(eventName, new CountDownLatch(0));
}
public synchronized void clearCurrentEvents(int numberOfUser, String eventName) {
if (this.eventNumbersByUser.containsKey(numberOfUser)) {
this.eventNumbersByUser.get(numberOfUser).put(eventName, new AtomicInteger(0));
this.setCountDown(numberOfUser, eventName, new CountDownLatch(0));
}
}
public synchronized void clearAllCurrentEvents() {
this.eventNumbers.keySet().forEach(eventName -> {
this.clearCurrentEvents(eventName);
});
}
public synchronized void clearAllCurrentEvents(int numberOfUser) {
if (this.eventNumbersByUser.containsKey(numberOfUser)) {
this.eventNumbersByUser.get(numberOfUser).keySet().forEach(eventName -> {
this.clearCurrentEvents(numberOfUser, eventName);
});
}
}
public void resetEventThread(boolean clearData) throws InterruptedException {
this.stopPolling(true, clearData);
this.pollingLatch.await();
@ -208,6 +276,7 @@ public class OpenViduEventManager {
this.stopPolling(false, clearData);
if (clearData) {
this.clearAllCurrentEvents();
this.eventNumbersByUser.keySet().forEach(user -> this.clearAllCurrentEvents(user));
}
this.isInterrupted.set(false);
this.pollingLatch = new CountDownLatch(1);
@ -259,6 +328,11 @@ public class OpenViduEventManager {
return this.eventNumbers.computeIfAbsent(eventName, k -> new AtomicInteger(0));
}
public AtomicInteger getNumEvents(int numberOfUser, String eventName) {
this.eventNumbersByUser.putIfAbsent(numberOfUser, new HashMap<>());
return this.eventNumbersByUser.get(numberOfUser).computeIfAbsent(eventName, k -> new AtomicInteger(0));
}
private void setCountDown(String eventName, CountDownLatch cd) {
this.eventCountdowns.put(eventName, cd);
for (int i = 0; i < getNumEvents(eventName).get(); i++) {
@ -266,10 +340,19 @@ public class OpenViduEventManager {
}
}
private void setCountDown(int numberOfUser, String eventName, CountDownLatch cd) {
this.eventCountdownsByUser.putIfAbsent(numberOfUser, new HashMap<>());
this.eventCountdownsByUser.get(numberOfUser).put(eventName, cd);
for (int i = 0; i < getNumEvents(numberOfUser, eventName).get(); i++) {
cd.countDown();
}
}
private void emitEvents() {
while (!this.eventQueue.isEmpty()) {
JsonObject userAndEvent = this.eventQueue.poll();
final JsonObject event = userAndEvent.get("event").getAsJsonObject();
final int numberOfUser = userAndEvent.get("user").getAsInt();
final String eventType = event.get("type").getAsString();
log.info(eventType);
@ -280,6 +363,12 @@ public class OpenViduEventManager {
execService.submit(callback);
}
}
if (this.eventCallbacksByUser.containsKey(numberOfUser)) {
for (RunnableCallback callback : this.eventCallbacksByUser.get(numberOfUser).get(eventType)) {
callback.setEventResult(event);
execService.submit(callback);
}
}
}
}
@ -294,14 +383,21 @@ public class OpenViduEventManager {
for (String e : events) {
JsonObject userAndEvent = JsonParser.parseString(e).getAsJsonObject();
final JsonObject event = userAndEvent.get("event").getAsJsonObject();
final int numberOfUser = userAndEvent.get("user").getAsInt();
final String eventType = event.get("type").getAsString();
this.eventQueue.add(userAndEvent);
getNumEvents(eventType).incrementAndGet();
getNumEvents(eventType).incrementAndGet();
if (this.eventCountdowns.get(eventType) != null) {
this.eventCountdowns.get(eventType).countDown();
}
getNumEvents(numberOfUser, eventType).incrementAndGet();
this.eventCountdownsByUser.putIfAbsent(numberOfUser, new HashMap<>());
if (this.eventCountdownsByUser.get(numberOfUser).get(eventType) != null) {
this.eventCountdownsByUser.get(numberOfUser).get(eventType).countDown();
}
}
}

8
openvidu-testapp/src/app/components/openvidu-instance/openvidu-instance.component.ts
View File

@ -523,13 +523,7 @@ export class OpenviduInstanceComponent implements OnInit, OnChanges, OnDestroy {
}
if (this.sessionEvents.speechToTextMessage) {
this.session.on('speechToTextMessage', (event: SpeechToTextEvent) => {
const displayedContent = {
connection: event.connection.connectionId,
text: event.text,
reason: event.reason,
lang: event.lang
}
this.updateEventList('speechToTextMessage', JSON.stringify(displayedContent), event);
this.updateEventList('speechToTextMessage', event.text, event);
if (event.reason === 'recognized') {
console.warn(event);
}