fixed test issues in CI

Author: slu-it

webtester-core/src/main/java/info/novatec/testit/webtester/internal/proxies/impls/AbstractIdentifyUsingCollectionImpl.java

@@ -5,7 +5,7 @@
 
 import java.lang.reflect.Method;
 import java.lang.reflect.ParameterizedType;
-import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 import java.util.function.Supplier;
 
@@ -36,49 +36,49 @@ abstract class AbstractIdentifyUsingCollectionImpl implements Implementation {
     List<? extends PageFragment> getStreamOfPageFragmentsFor(Method method) {
 
         IdentifyUsing identifyUsing = method.getAnnotation(IdentifyUsing.class);
-        Class<?> type = method.getReturnType();
         Class<PageFragment> genericType = getGenericType(method);
         By by = ByProducers.createBy(identifyUsing);
 
-        waitIfAnnotationPresent(method, type, genericType, by);
+        waitIfAnnotationPresent(method, genericType, by);
         return findPageFragments(genericType, by);
 
     }
 
-    private void waitIfAnnotationPresent(Method method, Class<?> type, Class<PageFragment> genericType, By by) {
+    private void waitIfAnnotationPresent(Method method, Class<PageFragment> genericType, By by) {
         WaitUntil annotation = method.getAnnotation(WaitUntil.class);
         if (annotation != null) {
-            doWaitUntil(annotation, type, genericType, by);
+            doWaitUntil(annotation, genericType, by);
         }
     }
 
     @SuppressWarnings("unchecked")
-    private void doWaitUntil(WaitUntil annotation, Class<?> type, Class<PageFragment> genericType, By by) {
+    private void doWaitUntil(WaitUntil annotation, Class<PageFragment> genericType, By by) {
+        Condition condition = getConditionInstance(annotation);
+        assertConditionCanHandleCollection(condition);
+        if (annotation.timeout() > 0) {
+            Wait.withTimeoutOf(annotation.timeout(), annotation.unit())
+                .untilSupplied(() -> findPageFragments(genericType, by))
+                .is(condition);
+        } else {
+            Wait.untilSupplied(() -> findPageFragments(genericType, by)).is(condition);
+        }
+    }
+
+    private Condition getConditionInstance(WaitUntil annotation) {
         try {
-            Condition condition = annotation.value().newInstance();
-            assertConditionCanHandleCollection(type, condition);
-            if (annotation.timeout() > 0) {
-                Wait.withTimeoutOf(annotation.timeout(), annotation.unit())
-                    .untilSupplied(() -> findPageFragments(genericType, by))
-                    .is(condition);
-            } else {
-                Wait.untilSupplied(() -> findPageFragments(genericType, by)).is(condition);
-            }
+            return annotation.value().newInstance();
         } catch (InstantiationException | IllegalAccessException e) {
             throw new IllegalSignatureException(COULD_NOT_CREATE_PREDICATE_INSTANCE_MSG, e);
         }
     }
 
-    private void assertConditionCanHandleCollection(Class<?> type, Condition condition) {
-        Class<? extends Condition> conditionClass = condition.getClass();
-        Method testMethod = Arrays.stream(conditionClass.getMethods())//
-            .filter(method -> "test".equals(method.getName()))
-            .findFirst()
-            .orElseThrow(() -> new IllegalStateException("test method not found"));
-        if (!testMethod.getParameterTypes()[0].isAssignableFrom(type)) {
+    @SuppressWarnings("unchecked")
+    private void assertConditionCanHandleCollection(Condition condition) {
+        try {
+            condition.test(Collections.<List<? extends PageFragment>>emptyList());
+        } catch (ClassCastException e) {
             throw new IllegalSignatureException(
-                "Condition '" + conditionClass.getSimpleName() + "' cant't handle method return type '"
-                    + type.getSimpleName() + "'");
+                "Condition '" + condition.getClass().getSimpleName() + "' cant't handle List<? extends PageFragment>");
         }
     }
 

webtester-core/src/test/java/info/novatec/testit/webtester/pagefragments/annotations/WaitUntilIntTest.java

@@ -1,12 +1,13 @@
 package info.novatec.testit.webtester.pagefragments.annotations;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 import java.util.List;
 import java.util.concurrent.TimeUnit;
 
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
 import utils.integration.BaseIntTest;
 
@@ -19,38 +20,44 @@
 import info.novatec.testit.webtester.waiting.TimeoutException;
 
 
-public class WaitUntilIntTest extends BaseIntTest {
+class WaitUntilIntTest extends BaseIntTest {
 
-    @Before
-    public void openPage() {
+    @BeforeEach
+    void openPage() {
         open("html/features/wait-annotation.html");
     }
 
     @Test
-    public void waitIsExecutedUntilConditionIsMet_PageFragment() {
+    void waitIsExecutedUntilConditionIsMet_PageFragment() {
         FeaturePage page = browser().create(FeaturePage.class);
         assertThat(page.becomesVisibleLater().isVisible());
     }
 
     @Test
-    public void waitIsExecutedUntilConditionIsMet_Collection() {
+    void waitIsExecutedUntilConditionIsMet_Collection() {
         CollectionsPage page = browser().create(CollectionsPage.class);
         assertThat(!page.becomeVisibleLater().isEmpty());
     }
 
-    @Test(expected = TimeoutException.class)
-    public void timeoutExceptionIsThrownIfElementNeverMatches_PageFragment() {
-        create(FeaturePage.class).neverPresent();
+    @Test
+    void timeoutExceptionIsThrownIfElementNeverMatches_PageFragment() {
+        assertThrows(TimeoutException.class, () -> {
+            create(FeaturePage.class).neverPresent();
+        });
     }
 
-    @Test(expected = TimeoutException.class)
-    public void timeoutExceptionIsThrownIfElementNeverMatches_Collection() {
-        create(CollectionsPage.class).neverPresent();
+    @Test
+    void timeoutExceptionIsThrownIfElementNeverMatches_Collection() {
+        assertThrows(TimeoutException.class, () -> {
+            create(CollectionsPage.class).neverPresent();
+        });
     }
 
-    @Test(expected = IllegalSignatureException.class)
-    public void exceptionInCaseTheConditionDoesNotSupportTheMethodsReturnType() {
-        create(CollectionsPage.class).wrongConditionType();
+    @Test
+    void exceptionInCaseTheConditionDoesNotSupportTheMethodsReturnType() {
+        assertThrows(IllegalSignatureException.class, () -> {
+            create(CollectionsPage.class).wrongConditionType();
+        });
     }
 
     /* test pages */