Added tester for RouterLink.

vaadin-testbench-unit-junit5/src/test/java/com/vaadin/flow/component/routerlink/AbstractTargetView.java

@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2000-2025 Vaadin Ltd
+ *
+ * This program is available under Vaadin Commercial License and Service Terms.
+ *
+ * See <https://vaadin.com/commercial-license-and-service-terms> for the full
+ * license.
+ */
+
+package com.vaadin.flow.component.routerlink;
+
+import com.vaadin.flow.component.Component;
+import com.vaadin.flow.component.HasComponents;
+import com.vaadin.flow.component.html.Span;
+
+abstract class AbstractTargetView extends Component implements HasComponents {
+
+    final Span message;
+
+    public AbstractTargetView() {
+        message = new Span();
+        add(message);
+    }
+}

vaadin-testbench-unit-junit5/src/test/java/com/vaadin/flow/component/routerlink/RouterLinkQueryParameterTargetView.java

@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2000-2025 Vaadin Ltd
+ *
+ * This program is available under Vaadin Commercial License and Service Terms.
+ *
+ * See <https://vaadin.com/commercial-license-and-service-terms> for the full
+ * license.
+ */
+package com.vaadin.flow.component.routerlink;
+
+import java.util.stream.Collectors;
+
+import com.vaadin.flow.component.Tag;
+import com.vaadin.flow.router.BeforeEnterEvent;
+import com.vaadin.flow.router.BeforeEnterObserver;
+import com.vaadin.flow.router.Route;
+
+@Tag(Tag.DIV)
+@Route(value = RouterLinkQueryParameterTargetView.ROUTE, registerAtStartup = false)
+public class RouterLinkQueryParameterTargetView extends AbstractTargetView
+        implements BeforeEnterObserver {
+
+    public static final String ROUTE = "router-link-query-parameter-target";
+
+    @Override
+    public void beforeEnter(BeforeEnterEvent event) {
+        var queryParameters = event.getLocation().getQueryParameters();
+        message.setText(
+                "Query Parameter Target View: { "
+                        + queryParameters.getParameters().entrySet().stream()
+                                .map(entry -> entry.getKey() + " = ["
+                                        + entry.getValue().stream().sorted()
+                                                .collect(Collectors
+                                                        .joining(", "))
+                                        + "]")
+                                .sorted().collect(Collectors.joining("; "))
+                        + " }");
+    }
+}

vaadin-testbench-unit-junit5/src/test/java/com/vaadin/flow/component/routerlink/RouterLinkRouteParameterTargetView.java

@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2000-2025 Vaadin Ltd
+ *
+ * This program is available under Vaadin Commercial License and Service Terms.
+ *
+ * See <https://vaadin.com/commercial-license-and-service-terms> for the full
+ * license.
+ */
+package com.vaadin.flow.component.routerlink;
+
+import java.util.stream.Collectors;
+
+import com.vaadin.flow.component.Tag;
+import com.vaadin.flow.router.BeforeEnterEvent;
+import com.vaadin.flow.router.BeforeEnterObserver;
+import com.vaadin.flow.router.Route;
+
+@Tag(Tag.DIV)
+@Route(value = RouterLinkRouteParameterTargetView.ROUTE
+        + RouterLinkRouteParameterTargetView.ROUTE_PARAMETERS, registerAtStartup = false)
+public class RouterLinkRouteParameterTargetView extends AbstractTargetView
+        implements BeforeEnterObserver {
+
+    public static final String ROUTE = "router-link-route-parameter-target";
+    public static final String ROUTE_PARAMETERS = "/:segment1?/static/:segment2/:segment3*";
+
+    @Override
+    public void beforeEnter(BeforeEnterEvent event) {
+        var routeParameters = event.getRouteParameters();
+
+        message.setText(
+                "Route Parameter Target View: { "
+                        + routeParameters.getParameterNames().stream()
+                                .map(name -> name + " = "
+                                        + routeParameters.get(name).orElse(""))
+                                .sorted().collect(Collectors.joining("; "))
+                        + " }");
+    }
+}

vaadin-testbench-unit-junit5/src/test/java/com/vaadin/flow/component/routerlink/RouterLinkStaticTargetView.java

@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2000-2025 Vaadin Ltd
+ *
+ * This program is available under Vaadin Commercial License and Service Terms.
+ *
+ * See <https://vaadin.com/commercial-license-and-service-terms> for the full
+ * license.
+ */
+package com.vaadin.flow.component.routerlink;
+
+import com.vaadin.flow.component.HasComponents;
+import com.vaadin.flow.component.Tag;
+import com.vaadin.flow.router.Route;
+
+@Tag(Tag.DIV)
+@Route(value = RouterLinkStaticTargetView.ROUTE, registerAtStartup = false)
+public class RouterLinkStaticTargetView extends AbstractTargetView
+        implements HasComponents {
+
+    public static final String ROUTE = "router-link-static-target";
+
+    public RouterLinkStaticTargetView() {
+        message.setText("Static Target View");
+    }
+}

vaadin-testbench-unit-junit5/src/test/java/com/vaadin/flow/component/routerlink/RouterLinkTesterTest.java

@@ -0,0 +1,150 @@
+/*
+ * Copyright (C) 2000-2025 Vaadin Ltd
+ *
+ * This program is available under Vaadin Commercial License and Service Terms.
+ *
+ * See <https://vaadin.com/commercial-license-and-service-terms> for the full
+ * license.
+ */
+package com.vaadin.flow.component.routerlink;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import com.vaadin.flow.router.RouteConfiguration;
+import com.vaadin.flow.router.RouterLink;
+import com.vaadin.testbench.unit.UIUnitTest;
+import com.vaadin.testbench.unit.ViewPackages;
+
+@ViewPackages
+class RouterLinkTesterTest extends UIUnitTest {
+
+    private RouterLinkView routerLinkView;
+
+    @BeforeEach
+    void init() {
+        RouteConfiguration.forApplicationScope()
+                .setAnnotatedRoute(RouterLinkView.class);
+        RouteConfiguration.forApplicationScope()
+                .setAnnotatedRoute(RouterLinkStaticTargetView.class);
+        RouteConfiguration.forApplicationScope()
+                .setAnnotatedRoute(RouterLinkUrlParameterTargetView.class);
+        RouteConfiguration.forApplicationScope()
+                .setAnnotatedRoute(RouterLinkQueryParameterTargetView.class);
+        RouteConfiguration.forApplicationScope()
+                .setAnnotatedRoute(RouterLinkRouteParameterTargetView.class);
+
+        routerLinkView = navigate(RouterLinkView.class);
+    }
+
+    @Test
+    void routerLink_targetless() {
+        // get router link
+        var $targetlessRouterLink = test(routerLinkView.targetlessRouterLink);
+        Assertions.assertNotNull($targetlessRouterLink,
+                "Tester for targetless RouterLink not initialized.");
+
+        // verify its href
+        Assertions.assertEquals("", $targetlessRouterLink.getHref());
+
+        // verify its click action fails due to no navigation target
+        Assertions.assertThrows(IllegalStateException.class,
+                $targetlessRouterLink::click);
+    }
+
+    @Test
+    void routerLink_static() {
+        // get router link
+        var $staticRouterLink = test(routerLinkView.staticRouterLink);
+        Assertions.assertNotNull($staticRouterLink,
+                "Tester for static RouterLink not initialized.");
+
+        // verify its href
+        Assertions.assertEquals(RouterLinkStaticTargetView.ROUTE,
+                $staticRouterLink.getHref());
+
+        assertNavigationSucceeded($staticRouterLink,
+                RouterLinkStaticTargetView.class, "Static Target View");
+    }
+
+    @Test
+    void routerLink_emptyUrlParameter() {
+        var $emptyUrlParameterRouterLink = test(
+                routerLinkView.emptyUrlParameterRouterLink);
+        Assertions.assertNotNull($emptyUrlParameterRouterLink,
+                "Tester for empty URL parameter RouterLink not initialized.");
+
+        // verify its href
+        Assertions.assertEquals(RouterLinkUrlParameterTargetView.ROUTE,
+                $emptyUrlParameterRouterLink.getHref());
+
+        assertNavigationSucceeded($emptyUrlParameterRouterLink,
+                RouterLinkUrlParameterTargetView.class,
+                "URL Parameter Target View: {  }");
+    }
+
+    @Test
+    void routerLink_urlParameter() {
+        var $urlParameterRouterLink = test(
+                routerLinkView.urlParameterRouterLink);
+        Assertions.assertNotNull($urlParameterRouterLink,
+                "Tester for URL parameter RouterLink not initialized.");
+
+        // verify its href
+        Assertions.assertEquals(
+                RouterLinkUrlParameterTargetView.ROUTE + "/parameter-value",
+                $urlParameterRouterLink.getHref());
+
+        assertNavigationSucceeded($urlParameterRouterLink,
+                RouterLinkUrlParameterTargetView.class,
+                "URL Parameter Target View: { parameter-value }");
+    }
+
+    @Test
+    void routerLink_queryParameter() {
+        var $queryParameterRouterLink = test(
+                routerLinkView.queryParameterRouterLink);
+        Assertions.assertNotNull($queryParameterRouterLink,
+                "Tester for QueryParameter RouterLink not initialized.");
+
+        // verify its href
+        Assertions.assertEquals(RouterLinkQueryParameterTargetView.ROUTE
+                + "?parameter2=parameter2-value1&parameter2=parameter2-value2&parameter1=parameter1-value",
+                $queryParameterRouterLink.getHref());
+
+        assertNavigationSucceeded($queryParameterRouterLink,
+                RouterLinkQueryParameterTargetView.class,
+                "Query Parameter Target View: { parameter1 = [parameter1-value]; parameter2 = [parameter2-value1, parameter2-value2] }");
+    }
+
+    @Test
+    void routerLink_routeParameter() {
+        var $routeParameterRouterLink = test(
+                routerLinkView.routeParameterRouterLink);
+        Assertions.assertNotNull($routeParameterRouterLink,
+                "Tester for RouteParameter RouterLink not initialized.");
+
+        // verify its href
+        Assertions.assertEquals(RouterLinkRouteParameterTargetView.ROUTE
+                + "/static/segment2-value/segment3-value1/segment3-value2",
+                $routeParameterRouterLink.getHref());
+
+        assertNavigationSucceeded($routeParameterRouterLink,
+                RouterLinkRouteParameterTargetView.class,
+                "Route Parameter Target View: { segment2 = segment2-value; segment3 = segment3-value1/segment3-value2 }");
+    }
+
+    private void assertNavigationSucceeded(RouterLinkTester<RouterLink> tester,
+            Class<? extends AbstractTargetView> expectedTarget,
+            String expectedMessage) {
+        // verify its click action returns correct target
+        var targetView = tester.click();
+        Assertions.assertInstanceOf(expectedTarget, targetView);
+        Assertions.assertSame(targetView, getCurrentView());
+
+        // verify navigation target is correct
+        Assertions.assertEquals(expectedMessage,
+                expectedTarget.cast(targetView).message.getText());
+    }
+}

vaadin-testbench-unit-junit5/src/test/java/com/vaadin/flow/component/routerlink/RouterLinkUrlParameterTargetView.java

@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2000-2025 Vaadin Ltd
+ *
+ * This program is available under Vaadin Commercial License and Service Terms.
+ *
+ * See <https://vaadin.com/commercial-license-and-service-terms> for the full
+ * license.
+ */
+package com.vaadin.flow.component.routerlink;
+
+import com.vaadin.flow.component.HasComponents;
+import com.vaadin.flow.component.Tag;
+import com.vaadin.flow.router.BeforeEvent;
+import com.vaadin.flow.router.HasUrlParameter;
+import com.vaadin.flow.router.OptionalParameter;
+import com.vaadin.flow.router.Route;
+
+@Tag(Tag.DIV)
+@Route(value = RouterLinkUrlParameterTargetView.ROUTE, registerAtStartup = false)
+public class RouterLinkUrlParameterTargetView extends AbstractTargetView
+        implements HasComponents, HasUrlParameter<String> {
+
+    public static final String ROUTE = "router-link-url-parameter-target";
+
+    @Override
+    public void setParameter(BeforeEvent event,
+            @OptionalParameter String parameter) {
+        message.setText("URL Parameter Target View: { "
+                + (parameter != null ? parameter : "") + " }");
+    }
+}

vaadin-testbench-unit-junit5/src/test/java/com/vaadin/flow/component/routerlink/RouterLinkView.java

@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2000-2025 Vaadin Ltd
+ *
+ * This program is available under Vaadin Commercial License and Service Terms.
+ *
+ * See <https://vaadin.com/commercial-license-and-service-terms> for the full
+ * license.
+ */
+package com.vaadin.flow.component.routerlink;
+
+import java.util.Map;
+
+import com.vaadin.flow.component.Component;
+import com.vaadin.flow.component.HasComponents;
+import com.vaadin.flow.component.Tag;
+import com.vaadin.flow.router.QueryParameters;
+import com.vaadin.flow.router.Route;
+import com.vaadin.flow.router.RouteParameters;
+import com.vaadin.flow.router.RouterLink;
+
+@Tag(Tag.DIV)
+@Route(value = RouterLinkView.ROUTE, registerAtStartup = false)
+public class RouterLinkView extends Component implements HasComponents {
+
+    public static final String ROUTE = "router-link-test";
+
+    final RouterLink targetlessRouterLink;
+    final RouterLink staticRouterLink;
+    final RouterLink emptyUrlParameterRouterLink;
+    final RouterLink urlParameterRouterLink;
+    final RouterLink queryParameterRouterLink;
+    final RouterLink routeParameterRouterLink;
+
+    public RouterLinkView() {
+        // targetless router link
+        targetlessRouterLink = new RouterLink();
+        targetlessRouterLink.setText("No Target");
+
+        // static router link
+        staticRouterLink = new RouterLink("Static Target",
+                RouterLinkStaticTargetView.class);
+
+        // url parameter router link - empty
+        emptyUrlParameterRouterLink = new RouterLink(
+                "Empty URL Parameter Target",
+                RouterLinkUrlParameterTargetView.class);
+
+        // url parameter router link - non-empty
+        urlParameterRouterLink = new RouterLink("URL Parameter Target",
+                RouterLinkUrlParameterTargetView.class, "parameter-value");
+
+        // query parameter router link
+        queryParameterRouterLink = new RouterLink("Query Parameter Target",
+                RouterLinkQueryParameterTargetView.class);
+        queryParameterRouterLink.setQueryParameters(QueryParameters.empty()
+                .merging("parameter1", "parameter1-value").merging("parameter2",
+                        "parameter2-value1", "parameter2-value2"));
+
+        // route parameter router link
+        routeParameterRouterLink = new RouterLink("Route Parameter Target",
+                RouterLinkRouteParameterTargetView.class,
+                new RouteParameters(
+                        Map.ofEntries(Map.entry("segment2", "segment2-value"),
+                                Map.entry("segment3",
+                                        "segment3-value1/segment3-value2"))));
+
+        add(targetlessRouterLink, staticRouterLink, emptyUrlParameterRouterLink,
+                urlParameterRouterLink, queryParameterRouterLink,
+                routeParameterRouterLink);
+    }
+}