From 169c2fc8fc6c69f7e60ae6e8c4859bb443fc501c Mon Sep 17 00:00:00 2001 From: Daeho Kwon Date: Mon, 20 Jan 2025 01:50:29 +0900 Subject: [PATCH 01/10] Add ofQueryParamMap method to mapping all query parameters to a Map Signed-off-by: Daeho Kwon --- .../annotation/AnnotatedValueResolver.java | 26 +++++++++++++++++++ .../AnnotatedValueResolverTest.java | 15 ++++++++++- 2 files changed, 40 insertions(+), 1 deletion(-) diff --git a/core/src/main/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolver.java b/core/src/main/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolver.java index 546c4f443a0..93f4d7ea0ac 100644 --- a/core/src/main/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolver.java +++ b/core/src/main/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolver.java @@ -48,6 +48,7 @@ import java.util.LinkedHashSet; import java.util.List; import java.util.Map; +import java.util.Map.Entry; import java.util.Objects; import java.util.Optional; import java.util.ServiceLoader; @@ -56,6 +57,7 @@ import java.util.function.Function; import java.util.function.Supplier; +import java.util.stream.Collectors; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -458,6 +460,11 @@ private static AnnotatedValueResolver of(AnnotatedElement annotatedElement, final Param param = annotatedElement.getAnnotation(Param.class); if (param != null) { final String name = findName(typeElement, param.value()); + // If the parameter is of type Map and the @Param annotation does not specify a value, + // map all query parameters into the Map. + if (Map.class.isAssignableFrom(type) && DefaultValues.isUnspecified(param.value())) { + return ofQueryParamMap(name, annotatedElement, typeElement, type, description); + } if (type == File.class || type == Path.class || type == MultipartFile.class) { return ofFileParam(name, annotatedElement, typeElement, type, description); } @@ -585,6 +592,25 @@ private static AnnotatedValueResolver ofQueryParam(String name, .build(); } + private static AnnotatedValueResolver ofQueryParamMap(String name, + AnnotatedElement annotatedElement, + AnnotatedElement typeElement, Class type, + DescriptionInfo description) { + + return new Builder(annotatedElement, type, name) + .annotationType(Param.class) + .typeElement(typeElement) + .description(description) + .aggregation(AggregationStrategy.FOR_FORM_DATA) + .resolver((resolver, ctx) -> ctx.queryParams().stream() + .collect(Collectors.toMap( + Entry::getKey, + Entry::getValue, + (existing, replacement) -> replacement + ))) + .build(); + } + private static AnnotatedValueResolver ofFileParam(String name, AnnotatedElement annotatedElement, AnnotatedElement typeElement, Class type, diff --git a/core/src/test/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolverTest.java b/core/src/test/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolverTest.java index 7fd3fe0b472..b0487deafd2 100644 --- a/core/src/test/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolverTest.java +++ b/core/src/test/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolverTest.java @@ -112,6 +112,7 @@ class AnnotatedValueResolverTest { static final ServiceRequestContext context; static final HttpRequest request; static final RequestHeaders originalHeaders; + static final String QUERY_PARAM_MAP = "queryParamMap"; static Map> successExpectAttrKeys; static Map> failExpectAttrKeys; @@ -358,12 +359,18 @@ private static void testResolver(AnnotatedValueResolver resolver) { } else { if (String.class.isAssignableFrom(resolver.elementType())) { assertThat(value).isEqualTo(""); + } else if(QUERY_PARAM_MAP.equals(resolver.httpElementName())) { + assertThat(value).isNotNull(); } else { assertThat(value).isNull(); } } } else { - assertThat(resolver.defaultValue()).isNotNull(); + if(QUERY_PARAM_MAP.equals(resolver.httpElementName())) { + assertThat(resolver.defaultValue()).isNull(); + } else { + assertThat(resolver.defaultValue()).isNotNull(); + } if (resolver.hasContainer() && List.class.isAssignableFrom(resolver.containerType())) { assertThat((List) value).hasSize(1) .containsOnly(resolver.defaultValue()); @@ -371,6 +378,11 @@ private static void testResolver(AnnotatedValueResolver resolver) { .isEqualTo(resolver.elementType()); } else if (resolver.shouldWrapValueAsOptional()) { assertThat(value).isEqualTo(Optional.of(resolver.defaultValue())); + } else if(QUERY_PARAM_MAP.equals(resolver.httpElementName())) { + assertThat(value).isNotNull(); + assertThat(value).isInstanceOf(Map.class); + assertThat((Map) value).size() + .isEqualTo(existingHttpParameters.size() + existingWithoutValueParameters.size()); } else { assertThat(value).isEqualTo(resolver.defaultValue()); } @@ -447,6 +459,7 @@ void method1(@Param String var1, @Param @Default Integer emptyParam2, @Param @Default List emptyParam3, @Param @Default List emptyParam4, + @Param Map queryParamMap, @Header List header1, @Header("header1") Optional> optionalHeader1, @Header String header2, From e152414e711f6027e7497000980a0e685d0b370f Mon Sep 17 00:00:00 2001 From: Daeho Kwon Date: Mon, 20 Jan 2025 02:24:57 +0900 Subject: [PATCH 02/10] Add ofQueryParamMap method to mapping all query parameters to a Map Signed-off-by: Daeho Kwon --- .../internal/server/annotation/AnnotatedValueResolver.java | 2 +- .../server/annotation/AnnotatedValueResolverTest.java | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/core/src/main/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolver.java b/core/src/main/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolver.java index 93f4d7ea0ac..9baf6d9c693 100644 --- a/core/src/main/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolver.java +++ b/core/src/main/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolver.java @@ -56,8 +56,8 @@ import java.util.function.BiFunction; import java.util.function.Function; import java.util.function.Supplier; - import java.util.stream.Collectors; + import org.slf4j.Logger; import org.slf4j.LoggerFactory; diff --git a/core/src/test/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolverTest.java b/core/src/test/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolverTest.java index b0487deafd2..1962b434e28 100644 --- a/core/src/test/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolverTest.java +++ b/core/src/test/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolverTest.java @@ -359,14 +359,14 @@ private static void testResolver(AnnotatedValueResolver resolver) { } else { if (String.class.isAssignableFrom(resolver.elementType())) { assertThat(value).isEqualTo(""); - } else if(QUERY_PARAM_MAP.equals(resolver.httpElementName())) { + } else if (QUERY_PARAM_MAP.equals(resolver.httpElementName())) { assertThat(value).isNotNull(); } else { assertThat(value).isNull(); } } } else { - if(QUERY_PARAM_MAP.equals(resolver.httpElementName())) { + if (QUERY_PARAM_MAP.equals(resolver.httpElementName())) { assertThat(resolver.defaultValue()).isNull(); } else { assertThat(resolver.defaultValue()).isNotNull(); @@ -378,7 +378,7 @@ private static void testResolver(AnnotatedValueResolver resolver) { .isEqualTo(resolver.elementType()); } else if (resolver.shouldWrapValueAsOptional()) { assertThat(value).isEqualTo(Optional.of(resolver.defaultValue())); - } else if(QUERY_PARAM_MAP.equals(resolver.httpElementName())) { + } else if (QUERY_PARAM_MAP.equals(resolver.httpElementName())) { assertThat(value).isNotNull(); assertThat(value).isInstanceOf(Map.class); assertThat((Map) value).size() From caee7ef8935c8ed7e76495c4094768415cdc919b Mon Sep 17 00:00:00 2001 From: Daeho Kwon Date: Tue, 21 Jan 2025 13:49:53 +0900 Subject: [PATCH 03/10] Add tests for `@Param Map` Signed-off-by: Daeho Kwon --- .../server/annotation/AnnotatedServiceTest.java | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/core/src/test/java/com/linecorp/armeria/internal/server/annotation/AnnotatedServiceTest.java b/core/src/test/java/com/linecorp/armeria/internal/server/annotation/AnnotatedServiceTest.java index bb5f68a8403..7c8fcc52c26 100644 --- a/core/src/test/java/com/linecorp/armeria/internal/server/annotation/AnnotatedServiceTest.java +++ b/core/src/test/java/com/linecorp/armeria/internal/server/annotation/AnnotatedServiceTest.java @@ -26,6 +26,7 @@ import java.util.ArrayList; import java.util.LinkedList; import java.util.List; +import java.util.Map; import java.util.Optional; import java.util.Set; import java.util.TreeSet; @@ -628,6 +629,14 @@ public String paramPrecedence(RequestContext ctx, validateContext(ctx); return username + '/' + password; } + + @Get("/param/map") + public String map (RequestContext ctx, @Param Map map) { + validateContext(ctx); + return map.isEmpty() ? "empty" : map.entrySet().stream() + .map(entry -> entry.getKey() + "=" + entry.getValue()) + .collect(Collectors.joining(", ")); + } } @ResponseConverter(UnformattedStringConverterFunction.class) @@ -1057,6 +1066,11 @@ void testParam() throws Exception { testStatusCode(hc, get("/7/param/default2"), 400); testBody(hc, get("/7/param/default_null"), "(null)"); + + // Case all query parameters test map + testBody(hc, get("/7/param/map?key1=value1&key2=value2"), + "key1=value1, key2=value2"); + testBody(hc, get("/7/param/map"), "empty"); } } From 5f6abad9b360efa293d38335a0fd333103e260ba Mon Sep 17 00:00:00 2001 From: Daeho Kwon Date: Tue, 21 Jan 2025 14:02:25 +0900 Subject: [PATCH 04/10] Add tests for `@Param Map` Signed-off-by: Daeho Kwon --- .../internal/server/annotation/AnnotatedServiceTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/src/test/java/com/linecorp/armeria/internal/server/annotation/AnnotatedServiceTest.java b/core/src/test/java/com/linecorp/armeria/internal/server/annotation/AnnotatedServiceTest.java index 7c8fcc52c26..c343b136c90 100644 --- a/core/src/test/java/com/linecorp/armeria/internal/server/annotation/AnnotatedServiceTest.java +++ b/core/src/test/java/com/linecorp/armeria/internal/server/annotation/AnnotatedServiceTest.java @@ -631,7 +631,7 @@ public String paramPrecedence(RequestContext ctx, } @Get("/param/map") - public String map (RequestContext ctx, @Param Map map) { + public String map(RequestContext ctx, @Param Map map) { validateContext(ctx); return map.isEmpty() ? "empty" : map.entrySet().stream() .map(entry -> entry.getKey() + "=" + entry.getValue()) From ffe3bb98bd19d801e9af0e8fa9d4b398d21eedc8 Mon Sep 17 00:00:00 2001 From: Daeho Kwon Date: Tue, 21 Jan 2025 23:12:46 +0900 Subject: [PATCH 05/10] Add tests for `@Param Map` Signed-off-by: Daeho Kwon --- .../annotation/AnnotatedServiceTest.java | 23 ++++++++++++++++++- .../AnnotatedValueResolverTest.java | 2 -- 2 files changed, 22 insertions(+), 3 deletions(-) diff --git a/core/src/test/java/com/linecorp/armeria/internal/server/annotation/AnnotatedServiceTest.java b/core/src/test/java/com/linecorp/armeria/internal/server/annotation/AnnotatedServiceTest.java index c343b136c90..78d7b926644 100644 --- a/core/src/test/java/com/linecorp/armeria/internal/server/annotation/AnnotatedServiceTest.java +++ b/core/src/test/java/com/linecorp/armeria/internal/server/annotation/AnnotatedServiceTest.java @@ -19,6 +19,7 @@ import static org.apache.hc.core5.http.HttpHeaders.CONTENT_TYPE; import static org.apache.hc.core5.http.HttpHeaders.IF_MATCH; import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; import java.io.IOException; import java.nio.charset.Charset; @@ -76,6 +77,7 @@ import com.linecorp.armeria.internal.testing.AnticipatedException; import com.linecorp.armeria.internal.testing.GenerateNativeImageTrace; import com.linecorp.armeria.server.HttpStatusException; +import com.linecorp.armeria.server.Server; import com.linecorp.armeria.server.ServerBuilder; import com.linecorp.armeria.server.ServiceRequestContext; import com.linecorp.armeria.server.TestConverters.NaiveIntConverterFunction; @@ -634,7 +636,7 @@ public String paramPrecedence(RequestContext ctx, public String map(RequestContext ctx, @Param Map map) { validateContext(ctx); return map.isEmpty() ? "empty" : map.entrySet().stream() - .map(entry -> entry.getKey() + "=" + entry.getValue()) + .map(entry -> entry.getKey() + '=' + entry.getValue()) .collect(Collectors.joining(", ")); } } @@ -934,6 +936,13 @@ public ResponseEntity responseEntityHttpResponse(RequestContext ct } } + public static class MyAnnotationService16 { + @Get("/param/map-invalid") + public String invalidMapParam(@Param("param") Map param) { + return "Should not reach here"; + } + } + @Test void testAnnotatedService() throws Exception { try (CloseableHttpClient hc = HttpClients.createMinimal()) { @@ -1367,6 +1376,18 @@ void testResponseEntity() throws Exception { } } + @Test + void testInvalidParamAnnotationUsageOnMap() { + assertThatThrownBy(() -> + Server.builder() + .annotatedService() + .build(new MyAnnotationService16()) + .build() + ) + .isInstanceOf(IllegalArgumentException.class) + .hasMessageContaining("Invalid @Param annotation on Map parameter"); + } + private enum UserLevel { LV1, LV2 diff --git a/core/src/test/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolverTest.java b/core/src/test/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolverTest.java index 1962b434e28..6caa7fe7ad5 100644 --- a/core/src/test/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolverTest.java +++ b/core/src/test/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolverTest.java @@ -359,8 +359,6 @@ private static void testResolver(AnnotatedValueResolver resolver) { } else { if (String.class.isAssignableFrom(resolver.elementType())) { assertThat(value).isEqualTo(""); - } else if (QUERY_PARAM_MAP.equals(resolver.httpElementName())) { - assertThat(value).isNotNull(); } else { assertThat(value).isNull(); } From f3ba5a2801333814d3d7550218b636f5a7df3d4e Mon Sep 17 00:00:00 2001 From: Daeho Kwon Date: Tue, 21 Jan 2025 23:15:36 +0900 Subject: [PATCH 06/10] Fix `@Param` handling to raise exception for Map with specified value Signed-off-by: Daeho Kwon --- .../server/annotation/AnnotatedValueResolver.java | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/core/src/main/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolver.java b/core/src/main/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolver.java index 9baf6d9c693..34611c91e8e 100644 --- a/core/src/main/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolver.java +++ b/core/src/main/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolver.java @@ -462,7 +462,15 @@ private static AnnotatedValueResolver of(AnnotatedElement annotatedElement, final String name = findName(typeElement, param.value()); // If the parameter is of type Map and the @Param annotation does not specify a value, // map all query parameters into the Map. - if (Map.class.isAssignableFrom(type) && DefaultValues.isUnspecified(param.value())) { + if (Map.class.isAssignableFrom(type)) { + if (DefaultValues.isSpecified(param.value())) { + throw new IllegalArgumentException( + String.format("Invalid @Param annotation on Map parameter: '%s'. " + + "The @Param annotation specifies a value ('%s'), which is not allowed. " + + "When using a Map, @Param must not specify a value. " + + "Please use @Param Map param without a value.", + annotatedElement, param.value())); + } return ofQueryParamMap(name, annotatedElement, typeElement, type, description); } if (type == File.class || type == Path.class || type == MultipartFile.class) { From 4675876c8bef1cb40333ddfdb17a30c2aae85347 Mon Sep 17 00:00:00 2001 From: Daeho Kwon <100909553+kwondh5217@users.noreply.github.com> Date: Wed, 5 Feb 2025 11:48:45 +0900 Subject: [PATCH 07/10] Remove verbose error message in AnnotatedValueResolver Co-authored-by: minux --- .../internal/server/annotation/AnnotatedValueResolver.java | 2 -- 1 file changed, 2 deletions(-) diff --git a/core/src/main/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolver.java b/core/src/main/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolver.java index 34611c91e8e..f7a18adb392 100644 --- a/core/src/main/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolver.java +++ b/core/src/main/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolver.java @@ -467,8 +467,6 @@ private static AnnotatedValueResolver of(AnnotatedElement annotatedElement, throw new IllegalArgumentException( String.format("Invalid @Param annotation on Map parameter: '%s'. " + "The @Param annotation specifies a value ('%s'), which is not allowed. " + - "When using a Map, @Param must not specify a value. " + - "Please use @Param Map param without a value.", annotatedElement, param.value())); } return ofQueryParamMap(name, annotatedElement, typeElement, type, description); From 91f59093e36264fb3ae83a167e0cfaf1f94cef09 Mon Sep 17 00:00:00 2001 From: Daeho Kwon Date: Wed, 5 Feb 2025 21:40:57 +0900 Subject: [PATCH 08/10] Polish AnnotatedValueResolver Signed-off-by: Daeho Kwon --- .../internal/server/annotation/AnnotatedValueResolver.java | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/core/src/main/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolver.java b/core/src/main/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolver.java index 34611c91e8e..eb35f4dafd9 100644 --- a/core/src/main/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolver.java +++ b/core/src/main/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolver.java @@ -56,7 +56,6 @@ import java.util.function.BiFunction; import java.util.function.Function; import java.util.function.Supplier; -import java.util.stream.Collectors; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -466,9 +465,7 @@ private static AnnotatedValueResolver of(AnnotatedElement annotatedElement, if (DefaultValues.isSpecified(param.value())) { throw new IllegalArgumentException( String.format("Invalid @Param annotation on Map parameter: '%s'. " + - "The @Param annotation specifies a value ('%s'), which is not allowed. " + - "When using a Map, @Param must not specify a value. " + - "Please use @Param Map param without a value.", + "The @Param annotation specifies a value ('%s'), which is not allowed. ", annotatedElement, param.value())); } return ofQueryParamMap(name, annotatedElement, typeElement, type, description); @@ -611,7 +608,7 @@ private static AnnotatedValueResolver ofQueryParamMap(String name, .description(description) .aggregation(AggregationStrategy.FOR_FORM_DATA) .resolver((resolver, ctx) -> ctx.queryParams().stream() - .collect(Collectors.toMap( + .collect(toImmutableMap( Entry::getKey, Entry::getValue, (existing, replacement) -> replacement From 8074b29ae38ff7f5a31d54187a230a3e394c2dad Mon Sep 17 00:00:00 2001 From: Daeho Kwon Date: Mon, 10 Feb 2025 16:08:57 +0900 Subject: [PATCH 09/10] Style reformat code according to LINE OSS guidelines Signed-off-by: Daeho Kwon --- .../annotation/AnnotatedValueResolver.java | 34 +++++++++---------- .../annotation/AnnotatedServiceTest.java | 18 +++++----- .../AnnotatedValueResolverTest.java | 3 +- 3 files changed, 28 insertions(+), 27 deletions(-) diff --git a/core/src/main/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolver.java b/core/src/main/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolver.java index eb35f4dafd9..b1f36e5b2c5 100644 --- a/core/src/main/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolver.java +++ b/core/src/main/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolver.java @@ -464,9 +464,9 @@ private static AnnotatedValueResolver of(AnnotatedElement annotatedElement, if (Map.class.isAssignableFrom(type)) { if (DefaultValues.isSpecified(param.value())) { throw new IllegalArgumentException( - String.format("Invalid @Param annotation on Map parameter: '%s'. " + - "The @Param annotation specifies a value ('%s'), which is not allowed. ", - annotatedElement, param.value())); + String.format("Invalid @Param annotation on Map parameter: '%s'. " + + "The @Param annotation specifies a value ('%s'), which is not allowed. ", + annotatedElement, param.value())); } return ofQueryParamMap(name, annotatedElement, typeElement, type, description); } @@ -598,22 +598,22 @@ private static AnnotatedValueResolver ofQueryParam(String name, } private static AnnotatedValueResolver ofQueryParamMap(String name, - AnnotatedElement annotatedElement, - AnnotatedElement typeElement, Class type, - DescriptionInfo description) { + AnnotatedElement annotatedElement, + AnnotatedElement typeElement, Class type, + DescriptionInfo description) { return new Builder(annotatedElement, type, name) - .annotationType(Param.class) - .typeElement(typeElement) - .description(description) - .aggregation(AggregationStrategy.FOR_FORM_DATA) - .resolver((resolver, ctx) -> ctx.queryParams().stream() - .collect(toImmutableMap( - Entry::getKey, - Entry::getValue, - (existing, replacement) -> replacement - ))) - .build(); + .annotationType(Param.class) + .typeElement(typeElement) + .description(description) + .aggregation(AggregationStrategy.FOR_FORM_DATA) + .resolver((resolver, ctx) -> ctx.queryParams().stream() + .collect(toImmutableMap( + Entry::getKey, + Entry::getValue, + (existing, replacement) -> replacement + ))) + .build(); } private static AnnotatedValueResolver ofFileParam(String name, diff --git a/core/src/test/java/com/linecorp/armeria/internal/server/annotation/AnnotatedServiceTest.java b/core/src/test/java/com/linecorp/armeria/internal/server/annotation/AnnotatedServiceTest.java index 78d7b926644..f32ff8afd5f 100644 --- a/core/src/test/java/com/linecorp/armeria/internal/server/annotation/AnnotatedServiceTest.java +++ b/core/src/test/java/com/linecorp/armeria/internal/server/annotation/AnnotatedServiceTest.java @@ -636,8 +636,8 @@ public String paramPrecedence(RequestContext ctx, public String map(RequestContext ctx, @Param Map map) { validateContext(ctx); return map.isEmpty() ? "empty" : map.entrySet().stream() - .map(entry -> entry.getKey() + '=' + entry.getValue()) - .collect(Collectors.joining(", ")); + .map(entry -> entry.getKey() + '=' + entry.getValue()) + .collect(Collectors.joining(", ")); } } @@ -1078,7 +1078,7 @@ void testParam() throws Exception { // Case all query parameters test map testBody(hc, get("/7/param/map?key1=value1&key2=value2"), - "key1=value1, key2=value2"); + "key1=value1, key2=value2"); testBody(hc, get("/7/param/map"), "empty"); } } @@ -1379,13 +1379,13 @@ void testResponseEntity() throws Exception { @Test void testInvalidParamAnnotationUsageOnMap() { assertThatThrownBy(() -> - Server.builder() - .annotatedService() - .build(new MyAnnotationService16()) - .build() + Server.builder() + .annotatedService() + .build(new MyAnnotationService16()) + .build() ) - .isInstanceOf(IllegalArgumentException.class) - .hasMessageContaining("Invalid @Param annotation on Map parameter"); + .isInstanceOf(IllegalArgumentException.class) + .hasMessageContaining("Invalid @Param annotation on Map parameter"); } private enum UserLevel { diff --git a/core/src/test/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolverTest.java b/core/src/test/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolverTest.java index 6caa7fe7ad5..4596b392886 100644 --- a/core/src/test/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolverTest.java +++ b/core/src/test/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolverTest.java @@ -380,7 +380,8 @@ private static void testResolver(AnnotatedValueResolver resolver) { assertThat(value).isNotNull(); assertThat(value).isInstanceOf(Map.class); assertThat((Map) value).size() - .isEqualTo(existingHttpParameters.size() + existingWithoutValueParameters.size()); + .isEqualTo(existingHttpParameters.size() + + existingWithoutValueParameters.size()); } else { assertThat(value).isEqualTo(resolver.defaultValue()); } From 4068f1962060f7d2f7df4ad44146eb52e0deff72 Mon Sep 17 00:00:00 2001 From: Daeho Kwon Date: Mon, 10 Feb 2025 16:21:38 +0900 Subject: [PATCH 10/10] Style reformat code according to LINE OSS guidelines Signed-off-by: Daeho Kwon --- .../internal/server/annotation/AnnotatedValueResolver.java | 3 ++- .../server/annotation/AnnotatedValueResolverTest.java | 4 ++-- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/core/src/main/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolver.java b/core/src/main/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolver.java index b1f36e5b2c5..0e93c707a8e 100644 --- a/core/src/main/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolver.java +++ b/core/src/main/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolver.java @@ -465,7 +465,8 @@ private static AnnotatedValueResolver of(AnnotatedElement annotatedElement, if (DefaultValues.isSpecified(param.value())) { throw new IllegalArgumentException( String.format("Invalid @Param annotation on Map parameter: '%s'. " + - "The @Param annotation specifies a value ('%s'), which is not allowed. ", + "The @Param annotation specifies a value ('%s'), " + + "which is not allowed. ", annotatedElement, param.value())); } return ofQueryParamMap(name, annotatedElement, typeElement, type, description); diff --git a/core/src/test/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolverTest.java b/core/src/test/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolverTest.java index 4596b392886..d3acd4c0422 100644 --- a/core/src/test/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolverTest.java +++ b/core/src/test/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolverTest.java @@ -380,8 +380,8 @@ private static void testResolver(AnnotatedValueResolver resolver) { assertThat(value).isNotNull(); assertThat(value).isInstanceOf(Map.class); assertThat((Map) value).size() - .isEqualTo(existingHttpParameters.size() - + existingWithoutValueParameters.size()); + .isEqualTo(existingHttpParameters.size() + + existingWithoutValueParameters.size()); } else { assertThat(value).isEqualTo(resolver.defaultValue()); }