merge TestRestClient into TestClient to simplify usage;

rename customClient() into externalClient();
rename subClient(Class) to restClient(Class) (uniform with ClientSupport)

Author: xvik

CHANGELOG.md

@@ -19,12 +19,12 @@
 * Unify ClientSupport and StubRest client APIs
     - New api is a wrapper above jersey client api to simplify test-specific configuration and validation
       (jersey api is still available). The request builder unifies all possible configurations in one place.  
-    - New common base class TestClient (and TestRestClient for rest clients, adding rest-specific methods)
+    - New common base client class TestClient
     - ClientSupport is a TestClient, but also could provide 3 special clients: appClient(), adminClient(), restClient()
       (restClient() is the same as StubRest client)
     - New sub clients could be created by applying additional path segments:
         client.subClient("/sub/path/)
-    - External api client could be created with support.customClient("som external url")
+    - External api client could be created with support.externalClient("som external url")
     - New client rest api based on real method calls: restClient(RestClass.class).method(mock -> mock.restMethod(args)).invoke()
       (target path and method type resolved from annotations, arguments used for request configuration)
     - Helper api for testing multipart requests: restClient(..).multipartMethod(..)

dropwizard-guicey/src/main/java/ru/vyarus/dropwizard/guice/test/ClientSupport.java

@@ -11,7 +11,6 @@
 import ru.vyarus.dropwizard.guice.test.client.ResourceClient;
 import ru.vyarus.dropwizard.guice.test.client.TestClient;
 import ru.vyarus.dropwizard.guice.test.client.TestClientFactory;
-import ru.vyarus.dropwizard.guice.test.client.TestRestClient;
 import ru.vyarus.dropwizard.guice.test.client.builder.TestRequestConfig;
 import ru.vyarus.dropwizard.guice.url.AppUrlBuilder;
 
@@ -45,9 +44,9 @@
  * The main idea of clients is the ability to create a client for any base path to shorten urls in tests.
  * Also, each client could declare its own defaults, applied to all requests (for example, useful for authorization).
  * <p>
- * There is also a specialized {@link #customClient(String, Object...)} for custom clients for creating remote api
+ * There is also a specialized {@link #externalClient(String, Object...)} for custom clients for creating remote api
  * clients (with the same client api):
- * {@code support.customClient("http://localhost:8080/some/path").get("/some/resource")}.
+ * {@code support.externalClient("http://localhost:8080/some/path").get("/some/resource")}.
  * <p>
  * There is a special class-based client constructor {@link #restClient(Class)} for resources. This makes tests
  * type-safe as the target resource path is obtained directly from the class annotation. Also, such clients
@@ -274,7 +273,7 @@ public String basePathRest() {
      * @param args variables for path placeholders (String.format() arguments)
      * @return jersey web target object
      * @see #basePathRoot()
-     * @see #customClient(String, Object...)  for external api client
+     * @see #externalClient(String, Object...)  for external api client
      */
     @Override
     public WebTarget target(final String path, final Object... args) {
@@ -381,9 +380,9 @@ public WebTarget targetRest(final String path, final Object... args) {
      *
      * @return rest client
      */
-    public TestRestClient<?> restClient() {
+    public TestClient<?> restClient() {
         // client INHERITS support defaults
-        return new TestRestClient<>(() -> getClient().target(basePathRest()), defaults);
+        return new TestClient<>(() -> getClient().target(basePathRest()), defaults);
     }
 
     /**
@@ -400,6 +399,7 @@ public TestRestClient<?> restClient() {
      * @param <K>      resource type
      * @return rest client for the given resource class
      */
+    @Override
     public <K> ResourceClient<K> restClient(final Class<K> resource) {
         final String target = UriBuilder.newInstance().path(resource).toTemplate();
         // client INHERITS support defaults
@@ -439,39 +439,20 @@ public TestClient<?> adminClient() {
     /**
      * Construct a client for external url.
      * <p>
-     * Example of variables usage: {@code customClient("http://localhost:8080/%s/other", 12)}.
+     * Example of variables usage: {@code externalClient("http://localhost:8080/%s/other", 12)}.
      * <p>
      * Will not inherit current defaults.
      *
      * @param url  external url, started with "http(s)" (could contain String.format() placeholders: %s)
      * @param args variables for path placeholders (String.format() arguments)
      * @return client for the given external url
      */
-    public TestClient<?> customClient(final String url, final Object... args) {
+    public TestClient<?> externalClient(final String url, final Object... args) {
         checkHttp(url);
         // custom external client - no defaults inherited
         return new TestClient<>(() -> getClient().target(String.format(url, args)), null);
     }
 
-    /**
-     * Construct a rest client for external url. If you have a resource class for external api, then construct
-     * client with base url first and then apply resource class:
-     * {@code customRestClient("http://localhost:8080/api/").subClient(ResourceClass.class)}.
-     * <p>
-     * Example of variables usage: {@code customRestClient("http://localhost:8080/api/%s/other", 12)}
-     * <p>
-     * Will not inherit current defaults.
-     *
-     * @param url  external url, started with "http(s)" (could contain String.format() placeholders: %s)
-     * @param args variables for path placeholders (String.format() arguments)
-     * @return rest client for the given external url
-     */
-    public TestRestClient<?> customRestClient(final String url, final Object... args) {
-        checkHttp(url);
-        // custom external client - no defaults inherited
-        return new TestRestClient<>(() -> getClient().target(String.format(url, args)), null);
-    }
-
     @Override
     public void close() throws Exception {
         synchronized (this) {

dropwizard-guicey/src/main/java/ru/vyarus/dropwizard/guice/test/client/ResourceClient.java

@@ -33,7 +33,7 @@
  * @author Vyacheslav Rusakov
  * @since 18.09.2025
  */
-public class ResourceClient<T> extends TestRestClient<TestRestClient<?>> {
+public class ResourceClient<T> extends TestClient<TestClient<?>> {
 
     private final Class<T> resource;
 
@@ -55,13 +55,9 @@ public ResourceClient(final @Nullable Supplier<WebTarget> root,
      * The same as {@link #method(ru.vyarus.dropwizard.guice.url.util.Caller, Object)}, but provides a helper
      * utility to easily stub multipart parameters (so these values could be used for request configuration).
      * <p>
-     * For the most common case {@code post(@FormDataParam("file") InputStream stream,
-     *
-     * @param consumer consumer calling resource method
-     * @param caller   multipart method caller
-     * @return pre-configured request builder instance
-     * @return builder instance for chained calls
-     * @FormDataParam("file") FormDataContentDisposition fileDetail)}:
+     * For the most common case
+     * {@code post(@FormDataParam("file") InputStream stream,  @FormDataParam("file")
+     * FormDataContentDisposition fileDetail)}:
      * <pre>{@code multipartMethod((instance, multipart) -> instance
      *             .post(multipart.fromClasspath("/some.txt"),
      *                   multipart.disposition("file", "some.txt"))}</pre>.
@@ -221,7 +217,7 @@ public TestClientRequestBuilder method(final String method, final @Nullable Obje
     }
 
     @Override
-    public <R> ResourceClient<R> subClient(final Class<R> resource) {
+    public <R> ResourceClient<R> restClient(final Class<R> resource) {
         // to minimize silly mistakes
         throw new UnsupportedOperationException("In context of resource, sub-resource client should be obtained "
                 + "with subResourceClient() method which ignores sub-resource @Path annotation (not used in "

dropwizard-guicey/src/main/java/ru/vyarus/dropwizard/guice/test/client/TestClient.java

@@ -12,6 +12,7 @@
 import ru.vyarus.dropwizard.guice.test.client.builder.TestClientDefaults;
 import ru.vyarus.dropwizard.guice.test.client.builder.TestClientRequestBuilder;
 import ru.vyarus.dropwizard.guice.test.client.builder.TestRequestConfig;
+import ru.vyarus.dropwizard.guice.url.util.RestPathUtils;
 
 import java.net.URI;
 import java.util.function.Consumer;
@@ -120,8 +121,7 @@
  * </code></pre>
  * <p>
  * {@link TestClient} is a general client class, but there are special client classes for rest (extending it):
- * {@link ru.vyarus.dropwizard.guice.test.client.TestRestClient} and
- * {@link ru.vyarus.dropwizard.guice.test.client.ResourceClient} (they could be obtained from the root
+ * {@link ru.vyarus.dropwizard.guice.test.client.ResourceClient} (could be obtained from the root) and
  * {@link ru.vyarus.dropwizard.guice.test.ClientSupport object (which is also a test client)})
  *
  * @param <T> actual client type
@@ -219,12 +219,12 @@ public Invocation.Builder request(final String path, final Object... args) {
      * @param args variables for path placeholders (String.format() arguments)
      * @return new client with a different root path
      */
-    public T subClient(final String path, final Object... args) {
+    public TestClient<?> subClient(final String path, final Object... args) {
         Preconditions.checkState(!path.toLowerCase().startsWith("http"),
                 "Only sub urls relative to current client url could be used. For completely custom external "
-                        + "client creation use ClientSupport.customClient()");
+                        + "client creation use ClientSupport.externalClient()");
         // client INHERITS current defaults
-        return createClient(String.format(path, args));
+        return new TestClient<>(() -> target(String.format(path, args)), defaults);
     }
 
     /**
@@ -240,10 +240,10 @@ public T subClient(final String path, final Object... args) {
      * @param consumer uri builder configurator
      * @return client with a constructed path (relative to the current client path)
      */
-    public T subClient(final Consumer<UriBuilder> consumer) {
+    public TestClient<?> subClient(final Consumer<UriBuilder> consumer) {
         final UriBuilder uriBuilder = UriBuilder.newInstance();
         consumer.accept(uriBuilder);
-        return createClient(uriBuilder.toString());
+        return new TestClient<>(() -> target(uriBuilder.toString()), defaults);
     }
 
     /**
@@ -260,6 +260,56 @@ public <K> ResourceClient<K> subClient(final Consumer<UriBuilder> consumer, fina
         return new ResourceClient<>(() -> target(uriBuilder.toString()), defaults, resource);
     }
 
+    /**
+     * Create a new sub-client for a specified resource class (appends a resource path, obtained from
+     * {@link jakarta.ws.rs.Path} annotation, to the current client path). Method is useful when generic
+     * rest path must be "typed" with a resource type (to be able to call resource methods directly).
+     * <p>
+     * In case of sub-resources, use {@link #subResourceClient(String, Class, Object...)} to properly specify
+     * sub-resource mapping path (from lookup method):
+     * {@code ResourceClient rest = client.subResourceClient("path", SubResource.class)}.
+     * IMPORTANT: this is NOT THE SAME: {@code client.subClient("path").restClient(SubResource.class)} because
+     * "restClient()" call would append path from resource, which is ignored for sub resources!.
+     * <p>
+     * Defaults could be used to declare path parameter values:
+     * {@code ResourceClient rest = client.restClient(Resource.class).defaultPathParam("param", "value")} where
+     * a resource class path is like "/some/{param}/path". With the default path param, there would be no need to
+     * declare it for each request call.
+     * <p>
+     * All defaults, configured for the current client, will be inherited in a sub-client. If this is not required,
+     * just clean defaults after creation: {@code client.subClient(ResClass.class).reset()}.
+     *
+     * @param resource resource class one to build a path for
+     * @return resource client (with a resource path, relative to the current client path)
+     * @param <R> resource type
+     */
+    public <R> ResourceClient<R> restClient(final Class<R> resource) {
+        final String target = RestPathUtils.getResourcePath(resource);
+        // last class used for a resource type to get methods on
+        return new ResourceClient<>(() -> target(target), defaults, resource);
+    }
+
+    /**
+     * Create a sub client for the sub-resource.
+     * <p>
+     * IMPORTANT: Path, declared on sub-resource class is ignored! Only lookup method path is counted.
+     * For example, {@code @Path("/sub") SubResource something() {...}} means all sub resource methods would be
+     * available on "/sub/*".
+     *
+     * @param path        sub-resource mapping path (from sub-resource method; could contain String.format()
+     *                    placeholders: %s)
+     * @param args variables for path placeholders (String.format() arguments)
+     * @param subResource sub-resource
+     * @param <R>         sub-resource type
+     * @return sub-resource client
+     */
+    public <R> ResourceClient<R> subResourceClient(final String path, final Class<R> subResource,
+                                                   final Object... args) {
+        final String target = String.format(path, args);
+        // last class used for a resource type to get methods on
+        return new ResourceClient<>(() -> target(target), defaults, subResource);
+    }
+
     /**
      * Cast current path as provided resource (full!) path. Use-case: resources were mapped on non-standard path
      * (admin context resources or internal resource mappings).
@@ -268,10 +318,10 @@ public <K> ResourceClient<K> subClient(final Consumer<UriBuilder> consumer, fina
      * already a resource path.
      *
      * @param resource resource type
-     * @param <T>      resource type
+     * @param <R>      resource type
      * @return rest client for provided resource
      */
-    public <T> ResourceClient<T> asRestClient(final Class<T> resource) {
+    public <R> ResourceClient<R> asRestClient(final Class<R> resource) {
         return new ResourceClient<>(() -> target("/"), defaults, resource);
     }
 
@@ -910,12 +960,14 @@ public TestClientRequestBuilder buildDelete(final String path, final Object... a
      * <p>
      * See {@link ru.vyarus.dropwizard.guice.test.client.builder.FormBuilder#param(String, Object)} for more details
      * about parameter values conversion.
+     * <p>
+     * Use null path to build entity: {@code buildForm(null).param().buildEntity()}.
      *
      * @param path target path, relative to rest root (could contain String.format() placeholders: %s)
      * @param args variables for path placeholders (String.format() arguments)
      * @return form builder
      */
-    public FormBuilder buildForm(final String path, final Object... args) {
+    public FormBuilder buildForm(final @Nullable String path, final Object... args) {
         return new FormBuilder(target(path, args), defaults);
     }
 
@@ -965,16 +1017,4 @@ private <R> R handleShortcut(final TestClientRequestBuilder request, final @Null
         // immediate result mapping with bypassing exceptions in rest stubs mode (if not exception mapper registered)
         return request.as(result);
     }
-
-    /**
-     * Create a client instance. It is assumed that all underlying classes would override this method to produce
-     * sub clients of the same type.
-     *
-     * @param target target path
-     * @return client insatnce
-     */
-    @SuppressWarnings("unchecked")
-    protected T createClient(final String target) {
-        return (T) new TestClient<>(() -> target(target), defaults);
-    }
 }