use immutable list except case when InvocationContext constructor takes list in parameters

Author: aleksandy

framework/src/play/Invoker.java

@@ -1,7 +1,6 @@
 package play;
 
 import java.lang.annotation.Annotation;
-import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashSet;
 import java.util.List;
@@ -26,6 +25,8 @@
 import play.libs.F.Promise;
 import play.utils.PThreadFactory;
 
+import static java.util.Collections.unmodifiableList;
+
 /**
  * Run some code in a Play! context
  */
@@ -115,8 +116,7 @@ public static InvocationContext current() {
         }
 
         public InvocationContext(String invocationType) {
-            this.invocationType = invocationType;
-            this.annotations = new ArrayList<>();
+            this(invocationType, List.of());
         }
 
         public InvocationContext(String invocationType, List<Annotation> annotations) {
@@ -125,16 +125,11 @@ public InvocationContext(String invocationType, List<Annotation> annotations) {
         }
 
         public InvocationContext(String invocationType, Annotation[] annotations) {
-            this.invocationType = invocationType;
-            this.annotations = Arrays.asList(annotations);
+            this(invocationType, List.of(annotations));
         }
 
         public InvocationContext(String invocationType, Annotation[]... annotations) {
-            this.invocationType = invocationType;
-            this.annotations = new ArrayList<>();
-            for (Annotation[] some : annotations) {
-                this.annotations.addAll(Arrays.asList(some));
-            }
+            this(invocationType, Arrays.stream(annotations).flatMap(Arrays::stream).toList());
         }
 
         public List<Annotation> getAnnotations() {
@@ -144,7 +139,7 @@ public List<Annotation> getAnnotations() {
         @SuppressWarnings("unchecked")
         public <T extends Annotation> T getAnnotation(Class<T> clazz) {
             for (Annotation annotation : annotations) {
-                if (annotation.annotationType().isAssignableFrom(clazz)) {
+                if (annotation.annotationType() == clazz) {
                     return (T) annotation;
                 }
             }
@@ -153,7 +148,7 @@ public <T extends Annotation> T getAnnotation(Class<T> clazz) {
 
         public <T extends Annotation> boolean isAnnotationPresent(Class<T> clazz) {
             for (Annotation annotation : annotations) {
-                if (annotation.annotationType().isAssignableFrom(clazz)) {
+                if (annotation.annotationType() == clazz) {
                     return true;
                 }
             }

framework/test-src/play/InvokerTest.java

@@ -0,0 +1,105 @@
+package play;
+
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Proxy;
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.Consumer;
+import java.util.stream.Stream;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class InvokerTest {
+
+    @Nested
+    class InvocationContextTest {
+
+        @Test void constructorStringShouldCreateInvocationContextWithEmptyAnnotationsCollection() {
+            String invocationType = "constructorString";
+            var context = new Invoker.InvocationContext(invocationType);
+            assertThat(context.getInvocationType()).isSameAs(invocationType);
+            assertThat(context.getAnnotations()).isEmpty();
+        }
+
+        @Test void constructorStringAndListShouldCreateInvocationContextWithSameAnnotationsCollection() {
+            String invocationType = "constructorStringAndList";
+            var annotations = List.of(stubAnnotationsFor(A.class, B.class, C.class, D.class));
+            var context = new Invoker.InvocationContext(invocationType, annotations);
+            assertThat(context.getInvocationType()).isSameAs(invocationType);
+            assertThat(context.getAnnotations()).isSameAs(annotations);
+        }
+
+        @Test void constructorStringAndOneDimensionArrayShouldCreateInvocationContextWithAnnotationsCollectionFromArray() {
+            String invocationType = "constructorStringAndOneDimensionArray";
+            var annotations = stubAnnotationsFor(A.class, B.class, C.class, D.class);
+            var context = new Invoker.InvocationContext(invocationType, annotations);
+
+            assertThat(context.getInvocationType()).isSameAs(invocationType);
+            assertThat(context.getAnnotations()).satisfiesExactly(
+                Arrays.stream(annotations)
+                    .<Consumer<? super Annotation>>map(annotation -> actual -> assertThat(actual).isSameAs(annotation))
+                    .toArray(Consumer[]::new)
+            );
+        }
+
+        @Test void constructorStringAndTwoDimensionsArrayShouldCreateInvocationContextWithAnnotationsCollectionFromArray() {
+            String invocationType = "constructorStringAndTwoDimensionsArray";
+            var abAnnotations = stubAnnotationsFor(A.class, B.class);
+            var cdAnnotations = stubAnnotationsFor(C.class, D.class);
+            var context = new Invoker.InvocationContext(invocationType, abAnnotations, cdAnnotations);
+
+            assertThat(context.getInvocationType()).isSameAs(invocationType);
+            assertThat(context.getAnnotations()).satisfiesExactly(
+                Stream.concat(Arrays.stream(abAnnotations), Arrays.stream(cdAnnotations))
+                    .<Consumer<? super Annotation>>map(annotation -> actual -> assertThat(actual).isSameAs(annotation))
+                    .toArray(Consumer[]::new)
+            );
+        }
+
+        @Test void getAnnotationShouldReturnFirstAnnotationFromList() {
+            var annotations = stubAnnotationsFor(A.class, B.class, C.class, B.class);
+            var context = new Invoker.InvocationContext("someInvocationType", annotations);
+            assertThat(context.getAnnotation(B.class)).isSameAs(annotations[1]);
+        }
+
+        @Test void getAnnotationShouldReturnNull() {
+            var context = new Invoker.InvocationContext("someInvocationType", stubAnnotationsFor(A.class, B.class, C.class));
+            assertThat(context.getAnnotation(D.class)).isNull();
+        }
+
+        @Test void isAnnotationPresentShouldReturnTrue() {
+            var annotations = stubAnnotationsFor(A.class, B.class, C.class, B.class);
+            var context = new Invoker.InvocationContext("someInvocationType", annotations);
+            assertThat(context.isAnnotationPresent(C.class)).isTrue();
+        }
+
+        @Test void isAnnotationPresentShouldReturnFalse() {
+            var context = new Invoker.InvocationContext("someInvocationType", stubAnnotationsFor(A.class, B.class, C.class));
+            assertThat(context.isAnnotationPresent(D.class)).isFalse();
+        }
+
+        @SafeVarargs
+        private Annotation[] stubAnnotationsFor(Class<? extends Annotation>... annotations) {
+            return Arrays.stream(annotations).map(this::stubAnnotationFor).toArray(Annotation[]::new);
+        }
+
+        private <T extends Annotation> T stubAnnotationFor(Class<T> annotation) {
+            InvocationHandler handler = (proxy, method, args) ->
+                method.getName().equals("annotationType") ? annotation : method.invoke(proxy, args);
+
+            return (T) Proxy.newProxyInstance(annotation.getClassLoader(), new Class[] { annotation }, handler);
+        }
+
+        private @interface A {}
+        private @interface B {}
+        private @interface C {}
+        private @interface D {}
+
+    }
+
+
+}