Skip to content

Commit 7151bb3

Browse files
PicazsooPicazsoo
committed
add tests
1 parent cec4212 commit 7151bb3

1 file changed

Lines changed: 230 additions & 0 deletions

File tree

‎modules/openapi-generator/src/test/java/org/openapitools/codegen/utils/ModelUtilsTest.java‎

Lines changed: 230 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -757,4 +757,234 @@ public void getParentNameMultipleInterfacesTest() {
757757
Schema composedSchema = allSchemas.get("RandomAnimalsResponse_animals_inner");
758758
assertNull(ModelUtils.getParentName(composedSchema, allSchemas));
759759
}
760+
761+
// -------------------------------------------------------------------------
762+
// resolveMaximum
763+
// -------------------------------------------------------------------------
764+
765+
@Test
766+
public void resolveMaximum_nullSchema_returnsNull() {
767+
assertNull(ModelUtils.resolveMaximum(new OpenAPI(), null));
768+
}
769+
770+
@Test
771+
public void resolveMaximum_noMaximumDefined_returnsNull() {
772+
OpenAPI openAPI = TestUtils.createOpenAPI();
773+
Schema<?> schema = new IntegerSchema();
774+
assertNull(ModelUtils.resolveMaximum(openAPI, schema));
775+
}
776+
777+
@Test
778+
public void resolveMaximum_inlineMaximum_returnsIt() {
779+
OpenAPI openAPI = TestUtils.createOpenAPI();
780+
Schema<?> schema = new IntegerSchema();
781+
schema.setMaximum(BigDecimal.valueOf(100));
782+
assertEquals(ModelUtils.resolveMaximum(openAPI, schema), BigDecimal.valueOf(100));
783+
}
784+
785+
@Test
786+
public void resolveMaximum_refToSchemaWithMaximum_resolvesRef() {
787+
OpenAPI openAPI = TestUtils.createOpenAPI();
788+
Schema<?> refTarget = new IntegerSchema();
789+
refTarget.setMaximum(BigDecimal.valueOf(50));
790+
openAPI.getComponents().addSchemas("MyInt", refTarget);
791+
792+
Schema<?> ref = new Schema<>().$ref("#/components/schemas/MyInt");
793+
assertEquals(ModelUtils.resolveMaximum(openAPI, ref), BigDecimal.valueOf(50));
794+
}
795+
796+
@Test
797+
public void resolveMaximum_allOf_returnsMostRestrictive() {
798+
OpenAPI openAPI = TestUtils.createOpenAPI();
799+
// allOf item with max=200 and item with max=50 — 50 should win
800+
Schema<?> loose = new IntegerSchema();
801+
loose.setMaximum(BigDecimal.valueOf(200));
802+
openAPI.getComponents().addSchemas("Loose", loose);
803+
804+
Schema<?> strict = new IntegerSchema();
805+
strict.setMaximum(BigDecimal.valueOf(50));
806+
openAPI.getComponents().addSchemas("Strict", strict);
807+
808+
Schema<?> schema = new Schema<>().allOf(Arrays.asList(
809+
new Schema<>().$ref("#/components/schemas/Loose"),
810+
new Schema<>().$ref("#/components/schemas/Strict")
811+
));
812+
assertEquals(ModelUtils.resolveMaximum(openAPI, schema), BigDecimal.valueOf(50));
813+
}
814+
815+
@Test
816+
public void resolveMaximum_inlineAndAllOf_mostRestrictiveWins() {
817+
OpenAPI openAPI = TestUtils.createOpenAPI();
818+
// allOf item has maximum=30, which is more restrictive than inline maximum=100
819+
Schema<?> allOfItem = new IntegerSchema();
820+
allOfItem.setMaximum(BigDecimal.valueOf(30));
821+
openAPI.getComponents().addSchemas("Base", allOfItem);
822+
823+
Schema<?> schema = new IntegerSchema();
824+
schema.setMaximum(BigDecimal.valueOf(100));
825+
schema.setAllOf(List.of(new Schema<>().$ref("#/components/schemas/Base")));
826+
assertEquals(ModelUtils.resolveMaximum(openAPI, schema), BigDecimal.valueOf(30));
827+
}
828+
829+
@Test
830+
public void resolveMaximum_allOfItemWithoutMaximum_ignored() {
831+
OpenAPI openAPI = TestUtils.createOpenAPI();
832+
openAPI.getComponents().addSchemas("NoMax", new IntegerSchema()); // no maximum
833+
834+
Schema<?> schema = new Schema<>().allOf(List.of(new Schema<>().$ref("#/components/schemas/NoMax")));
835+
assertNull(ModelUtils.resolveMaximum(openAPI, schema));
836+
}
837+
838+
// -------------------------------------------------------------------------
839+
// resolveMinimum
840+
// -------------------------------------------------------------------------
841+
842+
@Test
843+
public void resolveMinimum_nullSchema_returnsNull() {
844+
assertNull(ModelUtils.resolveMinimum(new OpenAPI(), null));
845+
}
846+
847+
@Test
848+
public void resolveMinimum_noMinimumDefined_returnsNull() {
849+
OpenAPI openAPI = TestUtils.createOpenAPI();
850+
assertNull(ModelUtils.resolveMinimum(openAPI, new IntegerSchema()));
851+
}
852+
853+
@Test
854+
public void resolveMinimum_inlineMinimum_returnsIt() {
855+
OpenAPI openAPI = TestUtils.createOpenAPI();
856+
Schema<?> schema = new IntegerSchema();
857+
schema.setMinimum(BigDecimal.valueOf(1));
858+
assertEquals(ModelUtils.resolveMinimum(openAPI, schema), BigDecimal.valueOf(1));
859+
}
860+
861+
@Test
862+
public void resolveMinimum_refToSchemaWithMinimum_resolvesRef() {
863+
OpenAPI openAPI = TestUtils.createOpenAPI();
864+
Schema<?> refTarget = new IntegerSchema();
865+
refTarget.setMinimum(BigDecimal.valueOf(5));
866+
openAPI.getComponents().addSchemas("MyInt", refTarget);
867+
868+
Schema<?> ref = new Schema<>().$ref("#/components/schemas/MyInt");
869+
assertEquals(ModelUtils.resolveMinimum(openAPI, ref), BigDecimal.valueOf(5));
870+
}
871+
872+
@Test
873+
public void resolveMinimum_allOf_returnsMostRestrictive() {
874+
OpenAPI openAPI = TestUtils.createOpenAPI();
875+
// allOf item with min=1 and item with min=10 — 10 should win (larger = more restrictive lower bound)
876+
Schema<?> permissive = new IntegerSchema();
877+
permissive.setMinimum(BigDecimal.valueOf(1));
878+
openAPI.getComponents().addSchemas("Permissive", permissive);
879+
880+
Schema<?> strict = new IntegerSchema();
881+
strict.setMinimum(BigDecimal.valueOf(10));
882+
openAPI.getComponents().addSchemas("Strict", strict);
883+
884+
Schema<?> schema = new Schema<>().allOf(Arrays.asList(
885+
new Schema<>().$ref("#/components/schemas/Permissive"),
886+
new Schema<>().$ref("#/components/schemas/Strict")
887+
));
888+
assertEquals(ModelUtils.resolveMinimum(openAPI, schema), BigDecimal.valueOf(10));
889+
}
890+
891+
@Test
892+
public void resolveMinimum_inlineAndAllOf_mostRestrictiveWins() {
893+
OpenAPI openAPI = TestUtils.createOpenAPI();
894+
// allOf item has minimum=20, which is more restrictive than inline minimum=0
895+
Schema<?> allOfItem = new IntegerSchema();
896+
allOfItem.setMinimum(BigDecimal.valueOf(20));
897+
openAPI.getComponents().addSchemas("Base", allOfItem);
898+
899+
Schema<?> schema = new IntegerSchema();
900+
schema.setMinimum(BigDecimal.valueOf(0));
901+
schema.setAllOf(List.of(new Schema<>().$ref("#/components/schemas/Base")));
902+
assertEquals(ModelUtils.resolveMinimum(openAPI, schema), BigDecimal.valueOf(20));
903+
}
904+
905+
@Test
906+
public void resolveMinimum_allOfItemWithoutMinimum_ignored() {
907+
OpenAPI openAPI = TestUtils.createOpenAPI();
908+
openAPI.getComponents().addSchemas("NoMin", new IntegerSchema());
909+
910+
Schema<?> schema = new Schema<>().allOf(List.of(new Schema<>().$ref("#/components/schemas/NoMin")));
911+
assertNull(ModelUtils.resolveMinimum(openAPI, schema));
912+
}
913+
914+
// -------------------------------------------------------------------------
915+
// resolveDefault
916+
// -------------------------------------------------------------------------
917+
918+
@Test
919+
public void resolveDefault_nullSchema_returnsNull() {
920+
assertNull(ModelUtils.resolveDefault(new OpenAPI(), null));
921+
}
922+
923+
@Test
924+
public void resolveDefault_noDefaultDefined_returnsNull() {
925+
OpenAPI openAPI = TestUtils.createOpenAPI();
926+
assertNull(ModelUtils.resolveDefault(openAPI, new IntegerSchema()));
927+
}
928+
929+
@Test
930+
public void resolveDefault_inlineDefault_returnsIt() {
931+
OpenAPI openAPI = TestUtils.createOpenAPI();
932+
Schema<?> schema = new IntegerSchema();
933+
schema.setDefault(10);
934+
assertEquals(ModelUtils.resolveDefault(openAPI, schema), 10);
935+
}
936+
937+
@Test
938+
public void resolveDefault_refToSchemaWithDefault_resolvesRef() {
939+
OpenAPI openAPI = TestUtils.createOpenAPI();
940+
Schema<?> refTarget = new IntegerSchema();
941+
refTarget.setDefault(0);
942+
openAPI.getComponents().addSchemas("MyInt", refTarget);
943+
944+
Schema<?> ref = new Schema<>().$ref("#/components/schemas/MyInt");
945+
assertEquals(ModelUtils.resolveDefault(openAPI, ref), 0);
946+
}
947+
948+
@Test
949+
public void resolveDefault_allOfItemHasDefault_returnsIt() {
950+
OpenAPI openAPI = TestUtils.createOpenAPI();
951+
Schema<?> allOfItem = new IntegerSchema();
952+
allOfItem.setDefault(20);
953+
openAPI.getComponents().addSchemas("Base", allOfItem);
954+
955+
// Inline schema has no default; allOf item has default=20
956+
Schema<?> schema = new Schema<>().allOf(List.of(new Schema<>().$ref("#/components/schemas/Base")));
957+
assertEquals(ModelUtils.resolveDefault(openAPI, schema), 20);
958+
}
959+
960+
@Test
961+
public void resolveDefault_inlineDefaultTakesPrecedenceOverAllOf() {
962+
OpenAPI openAPI = TestUtils.createOpenAPI();
963+
Schema<?> allOfItem = new IntegerSchema();
964+
allOfItem.setDefault(99);
965+
openAPI.getComponents().addSchemas("Base", allOfItem);
966+
967+
// Inline schema default=5 should win over allOf item default=99
968+
Schema<?> schema = new IntegerSchema();
969+
schema.setDefault(5);
970+
schema.setAllOf(List.of(new Schema<>().$ref("#/components/schemas/Base")));
971+
assertEquals(ModelUtils.resolveDefault(openAPI, schema), 5);
972+
}
973+
974+
@Test
975+
public void resolveDefault_allOfItemsNoDefault_returnsNull() {
976+
OpenAPI openAPI = TestUtils.createOpenAPI();
977+
openAPI.getComponents().addSchemas("Base", new IntegerSchema()); // no default
978+
979+
Schema<?> schema = new Schema<>().allOf(List.of(new Schema<>().$ref("#/components/schemas/Base")));
980+
assertNull(ModelUtils.resolveDefault(openAPI, schema));
981+
}
982+
983+
@Test
984+
public void resolveDefault_stringDefault_returnsIt() {
985+
OpenAPI openAPI = TestUtils.createOpenAPI();
986+
Schema<?> schema = new StringSchema();
987+
schema.setDefault("hello");
988+
assertEquals(ModelUtils.resolveDefault(openAPI, schema), "hello");
989+
}
760990
}

0 commit comments

Comments
 (0)