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

openvidu-test-e2e/src/main/java/io/openvidu/test/e2e/OpenViduEventManager.java

@@ -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();
+            }
         }
     }
 

openvidu-testapp/src/app/components/openvidu-instance/openvidu-instance.component.ts

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