chore: add more schema generation tests

Author: CarstenWickner

src/test/java/com/github/victools/jsonschema/generator/SchemaGeneratorComplexTypesTest.java

@@ -0,0 +1,244 @@
+/*
+ * Copyright 2019 VicTools.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.github.victools.jsonschema.generator;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import java.io.IOException;
+import java.io.InputStream;
+import java.lang.reflect.Type;
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.net.URI;
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Scanner;
+import junitparams.JUnitParamsRunner;
+import junitparams.Parameters;
+import junitparams.naming.TestCaseName;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.skyscreamer.jsonassert.JSONAssert;
+import org.skyscreamer.jsonassert.JSONCompareMode;
+
+/**
+ * Test for {@link SchemaGenerator} class.
+ */
+@RunWith(JUnitParamsRunner.class)
+public class SchemaGeneratorComplexTypesTest {
+
+    private static void populateTypeConfigPart(SchemaGeneratorTypeConfigPart<?> configPart, String descriptionPrefix) {
+        configPart
+                .withArrayMinItemsResolver(scope -> scope.isContainerType() ? 2 : null)
+                .withArrayMaxItemsResolver(scope -> scope.isContainerType() ? 100 : null)
+                .withArrayUniqueItemsResolver(scope -> scope.isContainerType() ? false : null)
+                .withDefaultResolver(scope -> scope.getType().isInstanceOf(Number.class) ? 1 : null)
+                .withDescriptionResolver(scope -> descriptionPrefix + scope.getSimpleTypeDescription())
+                .withEnumResolver(scope -> scope.getType().isInstanceOf(Number.class) ? Arrays.asList(1, 2, 3, 4, 5) : null)
+                .withEnumResolver(scope -> scope.getType().isInstanceOf(String.class) ? Arrays.asList("constant string value") : null)
+                .withAdditionalPropertiesResolver(SchemaGeneratorComplexTypesTest::resolveAdditionalProperties)
+                .withPatternPropertiesResolver(SchemaGeneratorComplexTypesTest::resolvePatternProperties)
+                .withNumberExclusiveMaximumResolver(scope -> scope.getType().isInstanceOf(Number.class) ? BigDecimal.TEN.add(BigDecimal.ONE) : null)
+                .withNumberExclusiveMinimumResolver(scope -> scope.getType().isInstanceOf(Number.class) ? BigDecimal.ZERO : null)
+                .withNumberInclusiveMaximumResolver(scope -> scope.getType().isInstanceOf(Number.class) ? BigDecimal.TEN : null)
+                .withNumberInclusiveMinimumResolver(scope -> scope.getType().isInstanceOf(Number.class) ? BigDecimal.ONE : null)
+                .withNumberMultipleOfResolver(scope -> scope.getType().isInstanceOf(Number.class) ? BigDecimal.ONE : null)
+                .withStringFormatResolver(scope -> scope.getType().isInstanceOf(String.class) ? "date" : null)
+                .withStringMaxLengthResolver(scope -> scope.getType().isInstanceOf(String.class) ? 256 : null)
+                .withStringMinLengthResolver(scope -> scope.getType().isInstanceOf(String.class) ? 1 : null)
+                .withStringPatternResolver(scope -> scope.getType().isInstanceOf(String.class) ? "^.{1,256}$" : null)
+                .withTitleResolver(scope -> scope.getSimpleTypeDescription());
+    }
+
+    private static Type resolveAdditionalProperties(TypeScope scope) {
+        if (scope.getType().isInstanceOf(TestClass2.class)) {
+            return Void.class;
+        }
+        if (scope.getType().isInstanceOf(TestClass4.class)) {
+            return scope.getTypeParameterFor(TestClass4.class, 1);
+        }
+        return null;
+    }
+
+    private static Map<String, Type> resolvePatternProperties(TypeScope scope) {
+        if (scope.getType().isInstanceOf(TestClass2.class)) {
+            Map<String, Type> patternProperties = new HashMap<>();
+            patternProperties.put("^generic.+$", scope.getTypeParameterFor(TestClass2.class, 0));
+            return patternProperties;
+        }
+        if (scope.getType().isInstanceOf(TestClass4.class)) {
+            return Collections.emptyMap();
+        }
+        return null;
+    }
+
+    private static void populateConfigPart(SchemaGeneratorConfigPart<? extends MemberScope<?, ?>> configPart, String descriptionPrefix) {
+        populateTypeConfigPart(configPart, descriptionPrefix);
+        configPart
+                .withNullableCheck(member -> !member.getName().startsWith("nested"))
+                .withRequiredCheck(member -> member.getName().startsWith("nested"));
+    }
+
+    Object parametersForTestGenerateSchema() {
+        Module neutralModule = configBuilder -> configBuilder.with((javaType, context) -> {
+            if (Integer.class == javaType.getErasedType()) {
+                ObjectNode customNode = configBuilder.getObjectMapper()
+                        .createObjectNode()
+                        .put("$comment", "custom definition for Integer.class");
+                return new CustomDefinition(customNode, false);
+            }
+            return null;
+        });
+        Module typeInGeneralModule = configBuilder -> populateTypeConfigPart(
+                configBuilder.with(Option.FORBIDDEN_ADDITIONAL_PROPERTIES_BY_DEFAULT).forTypesInGeneral(), "for type in general: ");
+        Module methodModule = configBuilder -> populateConfigPart(configBuilder.forMethods(), "looked-up from method: ");
+        Module fieldModule = configBuilder -> populateConfigPart(configBuilder.forFields(), "looked-up from field: ");
+        Module enumToStringModule = configBuilder -> configBuilder.with(Option.FLATTENED_ENUMS_FROM_TOSTRING);
+        return new Object[][]{
+            {"testclass1-FULL_DOCUMENTATION", OptionPreset.FULL_DOCUMENTATION, TestClass1.class, neutralModule},
+            {"testclass1-FULL_DOCUMENTATION-typeattributes", OptionPreset.FULL_DOCUMENTATION, TestClass1.class, typeInGeneralModule},
+            {"testclass1-JAVA_OBJECT-methodattributes", OptionPreset.JAVA_OBJECT, TestClass1.class, methodModule},
+            {"testclass1-PLAIN_JSON-fieldattributes", OptionPreset.PLAIN_JSON, TestClass1.class, fieldModule},
+            {"testclass2-array", OptionPreset.FULL_DOCUMENTATION, TestClass2[].class, neutralModule},
+            {"testclass3-FULL_DOCUMENTATION", OptionPreset.FULL_DOCUMENTATION, TestClass3.class, neutralModule},
+            {"testclass3-FULL_DOCUMENTATION-typeattributes", OptionPreset.FULL_DOCUMENTATION, TestClass3.class, typeInGeneralModule},
+            {"testclass3-JAVA_OBJECT-methodattributes", OptionPreset.JAVA_OBJECT, TestClass3.class, methodModule},
+            {"testclass3-PLAIN_JSON-fieldattributes", OptionPreset.PLAIN_JSON, TestClass3.class, fieldModule},
+            {"testenum-PLAIN_JSON-default", OptionPreset.PLAIN_JSON, TestEnum.class, neutralModule},
+            {"testenum-FULL_DOCUMENTATION-default", OptionPreset.FULL_DOCUMENTATION, TestEnum.class, neutralModule},
+            {"testenum-PLAIN_JSON-viaToString", OptionPreset.PLAIN_JSON, TestEnum.class, enumToStringModule}
+        };
+    }
+
+    @Test
+    @Parameters
+    @TestCaseName(value = "{method}({0}) [{index}]")
+    public void testGenerateSchema(String caseTitle, OptionPreset preset, Class<?> targetType, Module testModule) throws Exception {
+        SchemaGeneratorConfigBuilder configBuilder = new SchemaGeneratorConfigBuilder(new ObjectMapper(), preset);
+        configBuilder.with(testModule);
+        SchemaGenerator generator = new SchemaGenerator(configBuilder.build());
+
+        JsonNode result = generator.generateSchema(targetType);
+        // ensure that the generated definition keys are valid URIs without any characters requiring encoding
+        JsonNode definitions = result.get(SchemaConstants.TAG_DEFINITIONS);
+        if (definitions instanceof ObjectNode) {
+            Iterator<String> definitionKeys = ((ObjectNode) definitions).fieldNames();
+            while (definitionKeys.hasNext()) {
+                String key = definitionKeys.next();
+                Assert.assertEquals(key, new URI(key).toASCIIString());
+            }
+        }
+        JSONAssert.assertEquals('\n' + result.toString() + '\n',
+                loadResource(caseTitle + ".json"), result.toString(), JSONCompareMode.STRICT);
+    }
+
+    private static String loadResource(String resourcePath) throws IOException {
+        StringBuilder stringBuilder = new StringBuilder();
+        try (InputStream inputStream = SchemaGeneratorComplexTypesTest.class
+                .getResourceAsStream(resourcePath);
+                Scanner scanner = new Scanner(inputStream, StandardCharsets.UTF_8.name())) {
+            while (scanner.hasNext()) {
+                stringBuilder.append(scanner.nextLine()).append('\n');
+            }
+        }
+        String fileAsString = stringBuilder.toString();
+        return fileAsString;
+
+    }
+
+    private static class TestClass1 extends TestClass2<String> {
+
+        public static final Long CONSTANT = 5L;
+
+        private int primitiveValue;
+        private Integer ignoredInternalValue;
+
+        public int getPrimitiveValue() {
+            return this.primitiveValue;
+        }
+
+        public <A extends B, B extends Number> void calculateSomething(A param0, B param1) {
+            // nothing to do
+        }
+
+        public boolean isSimpleTestClass() {
+            return true;
+        }
+    }
+
+    private static class TestClass2<T> {
+
+        private T genericValue;
+        public T[] genericArray;
+
+        public T getGenericValue() {
+            return this.genericValue;
+        }
+    }
+
+    private static class TestClass3 {
+
+        private TestClass2<Long> nestedLong;
+        private TestClass2<TestClass1[]> nestedClass1Array;
+        private List<? extends TestClass2<Long>> nestedLongList;
+        private TestClass4<Integer, String> class4;
+
+        public TestClass2<Long> getNestedLong() {
+            return this.nestedLong;
+        }
+
+        public TestClass2<TestClass1[]> getNestedClass1Array() {
+            return this.nestedClass1Array;
+        }
+
+        public List<? extends TestClass2<Long>> getNestedLongList() {
+            return this.nestedLongList;
+        }
+
+        public TestClass4<Integer, String> getClass4() {
+            return this.class4;
+        }
+    }
+
+    private static class TestClass4<S, T> {
+
+        private TestClass2<TestClass2<T>> class2OfClass2OfT;
+        public Optional<S> optionalS;
+        public static final RoundingMode DEFAULT_ROUNDING_MODE = RoundingMode.HALF_UP;
+
+        public TestClass2<TestClass2<T>> getClass2OfClass2OfT() {
+            return this.class2OfClass2OfT;
+        }
+    }
+
+    private static enum TestEnum {
+        VALUE1, VALUE2, VALUE3;
+
+        @Override
+        public String toString() {
+            return "toString_" + this.name();
+        }
+    }
+}

src/test/java/com/github/victools/jsonschema/generator/SchemaGeneratorCustomDefinitionsTest.java

@@ -0,0 +1,99 @@
+/*
+ * Copyright 2019 VicTools.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.github.victools.jsonschema.generator;
+
+import com.fasterxml.classmate.ResolvedType;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import java.util.ArrayList;
+import java.util.Collection;
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * Test for {@link SchemaGenerator} class.
+ */
+public class SchemaGeneratorCustomDefinitionsTest {
+
+    @Test
+    public void testGenerateSchema_CustomDefinition() throws Exception {
+        CustomDefinitionProviderV2 customDefinitionProvider = (javaType, context) -> javaType.getErasedType() == Integer.class
+                ? new CustomDefinition(context.createDefinition(context.getTypeContext().resolve(String.class)))
+                : null;
+        SchemaGeneratorConfig config = new SchemaGeneratorConfigBuilder(new ObjectMapper())
+                .with(customDefinitionProvider)
+                .build();
+        SchemaGenerator generator = new SchemaGenerator(config);
+        JsonNode result = generator.generateSchema(Integer.class);
+        Assert.assertEquals(1, result.size());
+        Assert.assertEquals(SchemaConstants.TAG_TYPE_STRING, result.get(SchemaConstants.TAG_TYPE).asText());
+    }
+
+    @Test
+    public void testGenerateSchema_CustomCollectionDefinition() throws Exception {
+        final ObjectMapper objectMapper = new ObjectMapper();
+        String accessProperty = "stream().findFirst().orElse(null)";
+        CustomDefinitionProviderV2 customDefinitionProvider = (javaType, context) -> {
+            if (!javaType.isInstanceOf(Collection.class)) {
+                return null;
+            }
+            ResolvedType generic = context.getTypeContext().getContainerItemType(javaType);
+            return new CustomDefinition(objectMapper.createObjectNode()
+                    .put(SchemaConstants.TAG_TYPE, SchemaConstants.TAG_TYPE_OBJECT)
+                    .set(SchemaConstants.TAG_PROPERTIES, objectMapper.createObjectNode()
+                            .set(accessProperty, context.makeNullable(context.createDefinition(generic)))));
+        };
+        SchemaGeneratorConfig config = new SchemaGeneratorConfigBuilder(objectMapper)
+                .with(customDefinitionProvider)
+                .build();
+        SchemaGenerator generator = new SchemaGenerator(config);
+        JsonNode result = generator.generateSchema(ArrayList.class, String.class);
+        Assert.assertEquals(2, result.size());
+        Assert.assertEquals(SchemaConstants.TAG_TYPE_OBJECT, result.get(SchemaConstants.TAG_TYPE).asText());
+        Assert.assertNotNull(result.get(SchemaConstants.TAG_PROPERTIES));
+        Assert.assertNotNull(result.get(SchemaConstants.TAG_PROPERTIES).get(accessProperty));
+        JsonNode accessPropertyType = result.get(SchemaConstants.TAG_PROPERTIES).get(accessProperty).get(SchemaConstants.TAG_TYPE);
+        Assert.assertNotNull(accessPropertyType);
+        Assert.assertEquals(SchemaConstants.TAG_TYPE_STRING, accessPropertyType.get(0).asText());
+        Assert.assertEquals(SchemaConstants.TAG_TYPE_NULL, accessPropertyType.get(1).asText());
+    }
+
+    @Test
+    public void testGenerateSchema_CustomStandardDefinition() throws Exception {
+        CustomDefinitionProviderV2 customDefinitionProvider = new CustomDefinitionProviderV2() {
+            @Override
+            public CustomDefinition provideCustomSchemaDefinition(ResolvedType javaType, SchemaGenerationContext context) {
+                if (javaType.getErasedType() == Integer.class) {
+                    // using SchemaGenerationContext.createStandardDefinition() to avoid endless loop with this custom definition
+                    ObjectNode standardDefinition = context.createStandardDefinition(context.getTypeContext().resolve(Integer.class), this);
+                    standardDefinition.put("$comment", "custom override of Integer");
+                    return new CustomDefinition(standardDefinition);
+                }
+                return null;
+            }
+        };
+        SchemaGeneratorConfig config = new SchemaGeneratorConfigBuilder(new ObjectMapper())
+                .with(customDefinitionProvider)
+                .build();
+        SchemaGenerator generator = new SchemaGenerator(config);
+        JsonNode result = generator.generateSchema(Integer.class);
+        Assert.assertEquals(2, result.size());
+        Assert.assertEquals(SchemaConstants.TAG_TYPE_INTEGER, result.get(SchemaConstants.TAG_TYPE).asText());
+        Assert.assertEquals("custom override of Integer", result.get("$comment").asText());
+    }
+}