Bringing back static factory method to MappedFieldTypeDTO, as request…

…ed in review
Graylog2 · May 10, 2024 · c390cc7 · c390cc7
1 parent be495e9
commit c390cc7
Show file tree

Hide file tree

Showing 5 changed files with 26 additions and 27 deletions.
diff --git a/graylog2-server/src/main/java/org/graylog/plugins/views/search/rest/MappedFieldTypeDTO.java b/graylog2-server/src/main/java/org/graylog/plugins/views/search/rest/MappedFieldTypeDTO.java
@@ -29,8 +29,7 @@ public record MappedFieldTypeDTO(@JsonProperty("name") String name,
                                  @JsonProperty("unit") @Nullable UnitId unit
 ) {
 
-    public MappedFieldTypeDTO(final String name,
-                              final FieldTypes.Type type) {
-        this(name, type, null);
+    public static MappedFieldTypeDTO create(String name, FieldTypes.Type type) {
+        return new AutoValue_MappedFieldTypeDTO(name, type);
     }
 }
diff --git a/...g2-server/src/test/java/org/graylog/plugins/views/search/rest/FieldTypesResourceTest.java b/...g2-server/src/test/java/org/graylog/plugins/views/search/rest/FieldTypesResourceTest.java
@@ -43,7 +43,7 @@ public void allFieldTypesChecksPermissionsForStream() {
 
         final MappedFieldTypesService fieldTypesService = (streamIds, timeRange) -> {
             // for each streamID return a field that's called exactly like the streamID
-            return streamIds.stream().map(streamID -> new MappedFieldTypeDTO(streamID, FieldTypes.Type.builder().type("text").build())).collect(Collectors.toSet());
+            return streamIds.stream().map(streamID -> MappedFieldTypeDTO.create(streamID, FieldTypes.Type.builder().type("text").build())).collect(Collectors.toSet());
         };
 
         final FieldTypesResource resource = new FieldTypesResource(fieldTypesService);
@@ -65,7 +65,7 @@ public void allFieldTypesReturnsResultFromMappedFieldTypesService() {
 
         final MappedFieldTypesService fieldTypesService = (streamIds, timeRange) -> {
             if (ImmutableSet.of("2323", "4242").equals(streamIds) && timeRange.equals(RelativeRange.allTime())) {
-                return Collections.singleton(new MappedFieldTypeDTO("foobar",
+                return Collections.singleton(MappedFieldTypeDTO.create("foobar",
                         FieldTypes.Type.createType("long", ImmutableSet.of("numeric", "enumerable"))));
             } else {
                 return Collections.emptySet();
@@ -98,7 +98,7 @@ public void passesRequestedTimeRangeToMappedFieldTypesService() throws Exception
         final MappedFieldTypesService mappedFieldTypesService = (streamIds, timeRange) -> {
             if (timeRange.equals(RelativeRange.create(250))) {
                 final FieldTypes.Type fieldType = FieldTypes.Type.createType("long", ImmutableSet.of("numeric", "enumerable"));
-                final MappedFieldTypeDTO field = new MappedFieldTypeDTO("foobar", fieldType);
+                final MappedFieldTypeDTO field = MappedFieldTypeDTO.create("foobar", fieldType);
                 return Collections.singleton(field);
             } else {
                 throw new AssertionError("Expected relative range of 250");
@@ -127,7 +127,7 @@ public void byStreamChecksPermissionsForStream() {
         final MappedFieldTypesService fieldTypesService = (streamIds, timeRange) -> {
             // for each streamID return a field that's called exactly like the streamID
             return streamIds.stream()
-                    .map(streamID -> new MappedFieldTypeDTO(streamID, FieldTypes.Type.builder().type("text").build()))
+                    .map(streamID -> MappedFieldTypeDTO.create(streamID, FieldTypes.Type.builder().type("text").build()))
                     .collect(Collectors.toSet());
         };
 
@@ -151,7 +151,7 @@ public void byStreamReturnsTypesFromMappedFieldTypesService() {
         final MappedFieldTypesService fieldTypesService = (streamIds, timeRange) -> {
             if (ImmutableSet.of("2323", "4242").equals(streamIds) && timeRange.equals(RelativeRange.allTime())) {
                 final FieldTypes.Type fieldType = FieldTypes.Type.createType("long", ImmutableSet.of("numeric", "enumerable"));
-                final MappedFieldTypeDTO field = new MappedFieldTypeDTO("foobar", fieldType);
+                final MappedFieldTypeDTO field = MappedFieldTypeDTO.create("foobar", fieldType);
                 return Collections.singleton(field);
             } else {
                 throw new AssertionError("Expected allTime range and 2323, 4242 stream IDs");

diff --git a/...rg/graylog/plugins/views/search/rest/scriptingapi/mapping/MessageFieldTypeMapperTest.java b/...rg/graylog/plugins/views/search/rest/scriptingapi/mapping/MessageFieldTypeMapperTest.java
@@ -30,9 +30,9 @@ class MessageFieldTypeMapperTest {
     @Test
     void testSchemaCreation() {
         final Set<MappedFieldTypeDTO> knownFields = Set.of(
-                new MappedFieldTypeDTO("age", org.graylog2.indexer.fieldtypes.FieldTypeMapper.LONG_TYPE),
-                new MappedFieldTypeDTO("salary", org.graylog2.indexer.fieldtypes.FieldTypeMapper.DOUBLE_TYPE),
-                new MappedFieldTypeDTO("position", org.graylog2.indexer.fieldtypes.FieldTypeMapper.STRING_TYPE)
+                MappedFieldTypeDTO.create("age", org.graylog2.indexer.fieldtypes.FieldTypeMapper.LONG_TYPE),
+                MappedFieldTypeDTO.create("salary", org.graylog2.indexer.fieldtypes.FieldTypeMapper.DOUBLE_TYPE),
+                MappedFieldTypeDTO.create("position", org.graylog2.indexer.fieldtypes.FieldTypeMapper.STRING_TYPE)
         );
 
         final MessageFieldTypeMapper mapper = new MessageFieldTypeMapper(knownFields);

diff --git a/...rver/src/test/java/org/graylog/plugins/views/search/validation/TestValidationContext.java b/...rver/src/test/java/org/graylog/plugins/views/search/validation/TestValidationContext.java
@@ -48,7 +48,7 @@ public static TestValidationContext create(String queryString) {
     }
 
     public TestValidationContext knownMappedField(final String name, final String type) {
-        this.fields.add(new MappedFieldTypeDTO(name, FieldTypes.Type.builder().type(type).build()));
+        this.fields.add(MappedFieldTypeDTO.create(name, FieldTypes.Type.builder().type(type).build()));
         return this;
     }
 

diff --git a/...server/src/test/java/org/graylog2/indexer/fieldtypes/MappedFieldTypesServiceImplTest.java b/...server/src/test/java/org/graylog2/indexer/fieldtypes/MappedFieldTypesServiceImplTest.java
@@ -108,33 +108,33 @@ public void testDifferenceBetweenStreamAwareAndUnawareFieldTypeRetrieval() {
         Set<MappedFieldTypeDTO> result = this.mappedFieldTypesService.fieldTypesByStreamIds(Collections.singleton("stream1"), RelativeRange.allTime());
         //All fields are expected
         assertThat(result).containsExactlyInAnyOrder(
-                new MappedFieldTypeDTO("field1", FieldTypes.Type.createType("string", ImmutableSet.of("enumerable"))),
-                new MappedFieldTypeDTO("field2", FieldTypes.Type.createType("string", ImmutableSet.of("enumerable"))),
-                new MappedFieldTypeDTO("field3", FieldTypes.Type.createType("string", ImmutableSet.of("enumerable"))),
-                new MappedFieldTypeDTO("field4", FieldTypes.Type.createType("string", ImmutableSet.of("enumerable")))
+                MappedFieldTypeDTO.create("field1", FieldTypes.Type.createType("string", ImmutableSet.of("enumerable"))),
+                MappedFieldTypeDTO.create("field2", FieldTypes.Type.createType("string", ImmutableSet.of("enumerable"))),
+                MappedFieldTypeDTO.create("field3", FieldTypes.Type.createType("string", ImmutableSet.of("enumerable"))),
+                MappedFieldTypeDTO.create("field4", FieldTypes.Type.createType("string", ImmutableSet.of("enumerable")))
         );
 
         result = streamAwareMappedFieldTypesService.fieldTypesByStreamIds(Collections.singleton("stream1"), RelativeRange.allTime());
         //Stream-aware approach excludes field2, as it is present in stream2 only
         assertThat(result).containsExactlyInAnyOrder(
-                new MappedFieldTypeDTO("field1", FieldTypes.Type.createType("string", ImmutableSet.of("enumerable"))),
-                new MappedFieldTypeDTO("field3", FieldTypes.Type.createType("string", ImmutableSet.of("enumerable"))),
-                new MappedFieldTypeDTO("field4", FieldTypes.Type.createType("string", ImmutableSet.of("enumerable")))
+                MappedFieldTypeDTO.create("field1", FieldTypes.Type.createType("string", ImmutableSet.of("enumerable"))),
+                MappedFieldTypeDTO.create("field3", FieldTypes.Type.createType("string", ImmutableSet.of("enumerable"))),
+                MappedFieldTypeDTO.create("field4", FieldTypes.Type.createType("string", ImmutableSet.of("enumerable")))
         );
 
         result = this.mappedFieldTypesService.fieldTypesByStreamIds(Collections.singleton("stream2"), RelativeRange.allTime());
         //Field3 is excludes, as it is present only in "testIndex", ignored during indexLookup phase
         assertThat(result).containsExactlyInAnyOrder(
-                new MappedFieldTypeDTO("field1", FieldTypes.Type.createType("string", ImmutableSet.of("enumerable"))),
-                new MappedFieldTypeDTO("field2", FieldTypes.Type.createType("string", ImmutableSet.of("enumerable"))),
-                new MappedFieldTypeDTO("field4", FieldTypes.Type.createType("string", ImmutableSet.of("enumerable")))
+                MappedFieldTypeDTO.create("field1", FieldTypes.Type.createType("string", ImmutableSet.of("enumerable"))),
+                MappedFieldTypeDTO.create("field2", FieldTypes.Type.createType("string", ImmutableSet.of("enumerable"))),
+                MappedFieldTypeDTO.create("field4", FieldTypes.Type.createType("string", ImmutableSet.of("enumerable")))
         );
 
         //Stream-aware approach excludes, additionally to field3, field4 as well, as it is present in stream1 only
         result = streamAwareMappedFieldTypesService.fieldTypesByStreamIds(Collections.singleton("stream2"), RelativeRange.allTime());
         assertThat(result).containsExactlyInAnyOrder(
-                new MappedFieldTypeDTO("field1", FieldTypes.Type.createType("string", ImmutableSet.of("enumerable"))),
-                new MappedFieldTypeDTO("field2", FieldTypes.Type.createType("string", ImmutableSet.of("enumerable")))
+                MappedFieldTypeDTO.create("field1", FieldTypes.Type.createType("string", ImmutableSet.of("enumerable"))),
+                MappedFieldTypeDTO.create("field2", FieldTypes.Type.createType("string", ImmutableSet.of("enumerable")))
         );
     }
 
@@ -157,7 +157,7 @@ public void fieldsOfSameTypeDoNotReturnCompoundTypeIfPropertiesAreDifferent() {
 
         final Set<MappedFieldTypeDTO> result = this.mappedFieldTypesService.fieldTypesByStreamIds(Collections.singleton("stream1"), RelativeRange.allTime());
         assertThat(result).containsExactlyInAnyOrder(
-                new MappedFieldTypeDTO("field1", FieldTypes.Type.createType("string", ImmutableSet.of()))
+                MappedFieldTypeDTO.create("field1", FieldTypes.Type.createType("string", ImmutableSet.of()))
         );
     }
 
@@ -182,8 +182,8 @@ public void fieldsOfDifferentTypesDoReturnCompoundType() {
 
         final Set<MappedFieldTypeDTO> result = this.mappedFieldTypesService.fieldTypesByStreamIds(Collections.singleton("stream1"), RelativeRange.allTime());
         assertThat(result).containsExactlyInAnyOrder(
-                new MappedFieldTypeDTO("field2", FieldTypes.Type.createType("long", ImmutableSet.of("numeric", "enumerable"))),
-                new MappedFieldTypeDTO("field1", FieldTypes.Type.createType("compound(long,string)", ImmutableSet.of("compound")))
+                MappedFieldTypeDTO.create("field2", FieldTypes.Type.createType("long", ImmutableSet.of("numeric", "enumerable"))),
+                MappedFieldTypeDTO.create("field1", FieldTypes.Type.createType("compound(long,string)", ImmutableSet.of("compound")))
         );
     }