test: add support for client callable interfaces

Author: javier-godoy

src/test/java/com/flowingcode/vaadin/addons/chipfield/integration/AbstractChipfieldTest.java

@@ -1,15 +1,19 @@
 package com.flowingcode.vaadin.addons.chipfield.integration;
 
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
 import java.util.concurrent.TimeoutException;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
-import org.junit.Before;
 import org.openqa.selenium.By;
 import org.openqa.selenium.JavascriptExecutor;
+import org.openqa.selenium.WebDriver;
 import org.openqa.selenium.WebElement;
-import org.openqa.selenium.support.ui.ExpectedConditions;
-import org.openqa.selenium.support.ui.WebDriverWait;
 
 import com.vaadin.flow.component.ClientCallable;
 
@@ -21,38 +25,68 @@ protected AbstractChipfieldTest() {
 		super("it");
 	}
 
-	@Before
-	public void before() {
-		chipfield = $(ChipFieldElement.class).first();
+	@Override
+	public void setup() throws Exception {
+		super.setup();
+		chipfield = $(ChipFieldElement.class).waitForFirst();
 	}
+
 	/**
 	 * Call a {@link ClientCallable} defined on the integration view.
 	 *
 	 * @param callable  the client callable name
 	 * @param arguments arguments to be passed to the callable
-	 * @throws TimeoutException if the callable doesn't complete in 2 seconds.
+	 * @throws TimeoutException if the callable times out (see
+	 *                          {@link WebDriver.Timeouts#setScriptTimeout(long, java.util.concurrent.TimeUnit)
+	 *                          WebDriver.Timeouts}).
 	 * @throws RuntimeException if the callable fails.
 	 */
-	protected final void call(String callable, Object... arguments) {
+	protected final Object call(String callable, Object... arguments) {
 		WebElement view = getDriver().findElement(By.id("view"));
-		String result = "data-callable-result";
+		arguments = Optional.ofNullable(arguments).orElse(new Object[0]);
 
 		StringBuilder script = new StringBuilder();
 		script.append("var view = arguments[0];");
 		script.append("var callable = arguments[1];");
-		script.append("var result = arguments[2];");
-		script.append("view.removeAttribute(result);");
-		script.append("view.$server[callable](...arguments[3])");
-		script.append(" .then(()=>view.setAttribute(result,true))");
-		script.append(" .catch(()=>view.setAttribute(result,false));");
+		script.append("var callback = (result,success) => arguments[3]({result, success});");
+		script.append("view.$server[callable](...arguments[2])");
+		script.append(" .then(result=>callback(result, true))");
+		script.append(" .catch(()=>callback(undefined, false));");
 
-		((JavascriptExecutor) getDriver()).executeScript(script.toString(), view, callable, result, arguments);
+		@SuppressWarnings("unchecked")
+		Map<String, Object> result = (Map<String, Object>) ((JavascriptExecutor) getDriver()).executeAsyncScript(script.toString(), view, callable, arguments);
 
-		new WebDriverWait(getDriver(), 2, 100).until(ExpectedConditions.attributeToBeNotEmpty(view, result));
-		if (!Boolean.parseBoolean(view.getAttribute(result))) {
+		if (!(Boolean) result.get("success")) {
 			throw new RuntimeException(
 					String.format("server call failed: %s(%s)", callable, Stream.of(arguments).map(Object::toString).collect(Collectors.joining(","))));
 		}
+
+		return result.get("result");
+	}
+
+	/**
+	 * Create a TestBench proxy that invokes methods from the interface through a
+	 * client {@link #call}.
+	 */
+	protected final <T> T createCallableProxy(Class<T> intf) {
+		return intf.cast(Proxy.newProxyInstance(intf.getClassLoader(), new Class<?>[] { intf }, new InvocationHandler() {
+			@Override
+			public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+				Object result = call(method.getName(), args);
+
+				if (result == null || method.getReturnType() == Void.TYPE) {
+					return null;
+				}
+
+				if (method.getReturnType() == JsonArrayList.class) {
+					return JsonArrayList.wrapForTestbench((List<?>) result);
+				}
+
+				// this implementation is incomplete.
+				// other types that should be supported are: Double, Integer, Boolean, String, JsonValue
+				throw new ClassCastException(String.format("%s as %s", result.getClass().getName(), method.getReturnType().getName()));
+			}
+		}));
 	}
 
 }

src/test/java/com/flowingcode/vaadin/addons/chipfield/integration/JsonArrayList.java

@@ -0,0 +1,115 @@
+package com.flowingcode.vaadin.addons.chipfield.integration;
+
+import java.util.AbstractCollection;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Optional;
+import java.util.function.Function;
+
+import elemental.json.Json;
+import elemental.json.JsonValue;
+import elemental.json.impl.JreJsonArray;
+import lombok.experimental.Delegate;
+
+//Vaadin constraints:
+// - the result type of a @ClientCallable methods must be assignable to JsonValue.
+// - the runtime type of the result must be instanceof JreJsonValue.
+// - JreJsonValue can only be extended through intermediate classes.
+
+//Testbench constraints:
+// - Selenium already converts JSON to a List of objects (thus we have a "T" and not a JsonValue).
+// - In the integration test, we are interested on the "T" and not the raw JsonValue.
+// - It makes sense to implement Collection<T>, in order to facilitate the use of hamcrest Matchers
+// - JsonArray cannot implement List it because the return type of get(int) is incompatible.
+// - List isn't too helpul, because most Matchers work with Iterable/Collection.
+// - JsonValue methods (JS type coercion, etc.) are not needed in integration tests.
+@SuppressWarnings("serial")
+public interface JsonArrayList<T> extends JsonValue, Collection<T> {
+	
+	List<T> asList();
+
+	public static JsonArrayList<String> fromStringArray(List<String> list) {
+		return createArray(list, Json::create);
+	}
+	
+	public static JsonArrayList<Boolean> fromBooleanArray(List<Boolean> list) {
+		return createArray(list, Json::create);
+	}
+	
+	public static JsonArrayList<Double> fromDoubleArray(List<Double> list) {
+		return createArray(list, Json::create);
+	}
+		
+	/**
+	 * @deprecated. This method should be private.
+	 */
+	public static <T> JsonArrayList<T> createArray(List<T> list, Function<? super T, JsonValue> mapper) {
+		//this is the server-side flavor of JsonArrayList		
+		class JreJsonArrayList extends JreJsonArray implements JsonArrayList<T> {
+
+			@Delegate(excludes = JreJsonArray.class)
+			private Collection<T> list = new AbstractCollection<T>() {
+				//the delegate is only for the purpose of implementing Collection,
+				//but the Collection interface is unsupported on instances of JreJsonArrayList
+				@Override
+				public Iterator<T> iterator() {
+					throw new UnsupportedOperationException();
+				}
+
+				@Override
+				public int size() {
+					throw new UnsupportedOperationException();
+				}
+			};
+
+			public JreJsonArrayList(List<T> list, Function<? super T, JsonValue> mapper) {
+				super(Json.instance());
+				for (T t : list) {
+					set(length(), Optional.ofNullable(t).map(mapper).orElseGet(Json::createNull));
+				}
+			}
+
+			@Override
+			public List<T> asList() {
+				//JsonArrayList#asList is unsupported
+				throw new UnsupportedOperationException();
+			}
+		}
+		
+		return new JreJsonArrayList(list, mapper);
+	}
+
+	public static <T> JsonArrayList<T> wrapForTestbench(List<T> list) {
+		class TestbenchJsonArrayList implements JsonArrayList<T>, TestbenchValueWrapper {
+
+			@Delegate
+			private List<T> list;
+
+			public TestbenchJsonArrayList(List<T> list) {
+				this.list = list;
+			}
+
+			@Override
+			public List<T> asList() {
+				return list;
+			}
+
+			@Override
+			public boolean equals(Object obj) {
+				return list.equals(obj);
+			}
+
+			@Override
+			public String toString() {
+				return list.toString();
+			}
+		}
+
+		return new TestbenchJsonArrayList(list);
+
+	}
+
+}
+
+

src/test/java/com/flowingcode/vaadin/addons/chipfield/integration/TestbenchValueWrapper.java

@@ -0,0 +1,43 @@
+package com.flowingcode.vaadin.addons.chipfield.integration;
+
+import elemental.json.JsonType;
+import elemental.json.JsonValue;
+
+public interface TestbenchValueWrapper extends JsonValue {
+
+	@Override
+	default boolean asBoolean() {
+		throw new UnsupportedOperationException();
+	}
+
+	@Override
+	default double asNumber() {
+		throw new UnsupportedOperationException();
+	}
+
+	@Override
+	default String asString() {
+		throw new UnsupportedOperationException();
+	}
+
+	@Override
+	default JsonType getType() {
+		throw new UnsupportedOperationException();
+	}
+
+	@Override
+	default String toJson() {
+		throw new UnsupportedOperationException();
+	}
+
+	@Override
+	default boolean jsEquals(JsonValue value) {
+		throw new UnsupportedOperationException();
+	}
+
+	@Override
+	default Object toNative() {
+		throw new UnsupportedOperationException();
+	}
+
+}