From 8f1c89b3c5df70a807913b40c0aaeb33a9f249c9 Mon Sep 17 00:00:00 2001 From: Gerrett Date: Thu, 1 Aug 2024 17:33:02 -0500 Subject: [PATCH 1/3] Fixing compilation errors due to json-schema changes. Signed-off-by: Gerrett --- .../validation/SchemaValidationException.java | 13 +++++++++++++ .../validation/impl/RequestValidatorImpl.java | 5 ++--- .../validation/SchemaValidationExceptionTest.java | 7 ++++--- 3 files changed, 19 insertions(+), 6 deletions(-) diff --git a/src/main/java/io/vertx/openapi/validation/SchemaValidationException.java b/src/main/java/io/vertx/openapi/validation/SchemaValidationException.java index aaffe48..96f3da2 100644 --- a/src/main/java/io/vertx/openapi/validation/SchemaValidationException.java +++ b/src/main/java/io/vertx/openapi/validation/SchemaValidationException.java @@ -51,6 +51,19 @@ public static SchemaValidationException createInvalidValueResponseBody(OutputUni return new SchemaValidationException(msg, INVALID_VALUE, outputUnit, cause); } + public static ValidatorException createErrorFromOutputUnitType(Parameter parameter, OutputUnit outputUnit, + JsonSchemaValidationException cause) { + switch(outputUnit.getErrorType()) { + case MISSING_VALUE: + return createMissingRequiredParameter(parameter); + case INVALID_VALUE: + case NONE: + default: + return createInvalidValueParameter(parameter, outputUnit, cause); + } + + } + /** * Returns the related OutputUnit of the validation error. * diff --git a/src/main/java/io/vertx/openapi/validation/impl/RequestValidatorImpl.java b/src/main/java/io/vertx/openapi/validation/impl/RequestValidatorImpl.java index 4f2a867..f438b00 100644 --- a/src/main/java/io/vertx/openapi/validation/impl/RequestValidatorImpl.java +++ b/src/main/java/io/vertx/openapi/validation/impl/RequestValidatorImpl.java @@ -44,8 +44,7 @@ import static io.vertx.openapi.contract.Style.LABEL; import static io.vertx.openapi.contract.Style.MATRIX; import static io.vertx.openapi.contract.Style.SIMPLE; -import static io.vertx.openapi.validation.SchemaValidationException.createInvalidValueParameter; -import static io.vertx.openapi.validation.SchemaValidationException.createInvalidValueRequestBody; +import static io.vertx.openapi.validation.SchemaValidationException.*; import static io.vertx.openapi.validation.ValidatorErrorType.MISSING_REQUIRED_PARAMETER; import static io.vertx.openapi.validation.ValidatorErrorType.UNSUPPORTED_VALUE_FORMAT; import static io.vertx.openapi.validation.ValidatorException.createMissingRequiredParameter; @@ -132,7 +131,7 @@ public RequestParameter validateParameter(Parameter parameter, RequestParameter result.checkValidity(); return new RequestParameterImpl(transformedValue); } catch (JsonSchemaValidationException e) { - throw createInvalidValueParameter(parameter, result, e); + throw createErrorFromOutputUnitType(parameter, result, e); } } diff --git a/src/test/java/io/vertx/tests/validation/SchemaValidationExceptionTest.java b/src/test/java/io/vertx/tests/validation/SchemaValidationExceptionTest.java index 64faeb9..f5fe1b1 100644 --- a/src/test/java/io/vertx/tests/validation/SchemaValidationExceptionTest.java +++ b/src/test/java/io/vertx/tests/validation/SchemaValidationExceptionTest.java @@ -15,6 +15,7 @@ import com.google.common.collect.ImmutableList; import io.vertx.json.schema.JsonSchema; import io.vertx.json.schema.JsonSchemaValidationException; +import io.vertx.json.schema.OutputErrorType; import io.vertx.json.schema.OutputUnit; import io.vertx.openapi.contract.Parameter; import io.vertx.openapi.validation.SchemaValidationException; @@ -34,11 +35,11 @@ class SchemaValidationExceptionTest { mockParameter("dummy", PATH, LABEL, false, JsonSchema.of(intSchema().toJson())); private static final JsonSchemaValidationException DUMMY_CAUSE = new JsonSchemaValidationException("dummy", - new Exception(), "dummyLocation"); + new Exception(), "dummyLocation", OutputErrorType.INVALID_VALUE); private static final OutputUnit DUMMY_ERROR_UNIT = new OutputUnit("instanceLocation", "absoluteKeywordLocation", - "keywordLocation", "error"); + "keywordLocation", "error", OutputErrorType.INVALID_VALUE); private static final OutputUnit DUMMY_OUTPUT_UNIT = new OutputUnit("instanceLocation2", "absoluteKeywordLocation2", - "keywordLocation2", "error2"); + "keywordLocation2", "error2", OutputErrorType.MISSING_VALUE); @BeforeAll static void setup() { From 85016cfa906f184307000ae90b51def5cae0b99e Mon Sep 17 00:00:00 2001 From: Gerrett Pape Date: Fri, 2 Aug 2024 19:43:31 -0500 Subject: [PATCH 2/3] merging down feature #78 Signed-off-by: Gerrett --- .../openapi/contract/OpenAPIContract.java | 35 +++++----- .../openapi/contract/OpenAPIVersion.java | 35 +++++++++- .../tests/contract/OpenAPIContractTest.java | 68 ++++++++++++++++++- .../tests/contract/OpenAPIVersionTest.java | 36 ++++++++-- .../additional_schema_files/dereferenced.json | 46 +++++++++++++ .../additional_schema_files/name.yaml | 5 ++ .../additional_schema_files/openapi.yaml | 29 ++++++++ .../contract/split/malformedComponents.json | 6 ++ .../split/validJsonSchemaComponents.json | 51 ++++++++++++++ 9 files changed, 284 insertions(+), 27 deletions(-) create mode 100644 src/test/resources/io/vertx/tests/contract/additional_schema_files/dereferenced.json create mode 100644 src/test/resources/io/vertx/tests/contract/additional_schema_files/name.yaml create mode 100644 src/test/resources/io/vertx/tests/contract/additional_schema_files/openapi.yaml create mode 100644 src/test/resources/io/vertx/tests/contract/split/malformedComponents.json create mode 100644 src/test/resources/io/vertx/tests/contract/split/validJsonSchemaComponents.json diff --git a/src/main/java/io/vertx/openapi/contract/OpenAPIContract.java b/src/main/java/io/vertx/openapi/contract/OpenAPIContract.java index 1cb1cc9..a7ba07e 100644 --- a/src/main/java/io/vertx/openapi/contract/OpenAPIContract.java +++ b/src/main/java/io/vertx/openapi/contract/OpenAPIContract.java @@ -108,34 +108,37 @@ static Future from(Vertx vertx, JsonObject unresolvedContract, ContextInternal ctx = (ContextInternal) vertx.getOrCreateContext(); Promise promise = ctx.promise(); - version.getRepository(vertx, baseUri).compose(repository -> { - List> validationFutures = new ArrayList<>(additionalContractFiles.size()); + version.getRepository(vertx, baseUri) + .compose(repository -> { + List> validationFutures = new ArrayList<>(additionalContractFiles.size()); for (String ref : additionalContractFiles.keySet()) { // Todo: As soon a more modern Java version is used the validate part could be extracted in a private static // method and reused below. - Future validationFuture = version.validate(vertx, repository, - additionalContractFiles.get(ref)).map(res -> { - try { - res.checkValidity(); - return repository.dereference(ref, JsonSchema.of(ref, additionalContractFiles.get(ref))); - } catch (JsonSchemaValidationException e) { - String msg = "Found issue in specification for reference: " + ref; - throw createInvalidContract(msg, e); - } - }); + JsonObject file = additionalContractFiles.get(ref); + Future validationFuture = version.validateAdditionalContractFile(vertx, repository, file) + .compose(v -> vertx.executeBlocking(() -> repository.dereference(ref, JsonSchema.of(ref, file)))); + validationFutures.add(validationFuture); } return Future.all(validationFutures).map(repository); }).compose(repository -> - version.validate(vertx, repository, unresolvedContract).compose(res -> { + version.validateContract(vertx, repository, unresolvedContract).compose(res -> { try { res.checkValidity(); return version.resolve(vertx, repository, unresolvedContract); - } catch (JsonSchemaValidationException e) { + } catch (JsonSchemaValidationException | UnsupportedOperationException e) { return failedFuture(createInvalidContract(null, e)); } - }).map(resolvedSpec -> (OpenAPIContract) new OpenAPIContractImpl(resolvedSpec, version, repository)) - ).onComplete(promise); + }) + .map(resolvedSpec -> (OpenAPIContract) new OpenAPIContractImpl(resolvedSpec, version, repository)) + ).recover(e -> { + //Convert any non-openapi exceptions into an OpenAPIContractException + if(e instanceof OpenAPIContractException) { + return failedFuture(e); + } + + return failedFuture(createInvalidContract("Found issue in specification for reference: " + e.getMessage(), e)); + }).onComplete(promise); return promise.future(); } diff --git a/src/main/java/io/vertx/openapi/contract/OpenAPIVersion.java b/src/main/java/io/vertx/openapi/contract/OpenAPIVersion.java index 47ff800..a6d00a0 100644 --- a/src/main/java/io/vertx/openapi/contract/OpenAPIVersion.java +++ b/src/main/java/io/vertx/openapi/contract/OpenAPIVersion.java @@ -15,7 +15,13 @@ import io.vertx.core.Future; import io.vertx.core.Vertx; import io.vertx.core.json.JsonObject; -import io.vertx.json.schema.*; +import io.vertx.json.schema.Draft; +import io.vertx.json.schema.JsonFormatValidator; +import io.vertx.json.schema.JsonSchema; +import io.vertx.json.schema.JsonSchemaOptions; +import io.vertx.json.schema.JsonSchemaValidationException; +import io.vertx.json.schema.OutputUnit; +import io.vertx.json.schema.SchemaRepository; import io.vertx.openapi.impl.OpenAPIFormatValidator; import java.util.ArrayList; @@ -73,13 +79,36 @@ public static OpenAPIVersion fromContract(JsonObject contract) { } } - public Future validate(Vertx vertx, SchemaRepository repo, JsonObject contract) { + public Future validateContract(Vertx vertx, SchemaRepository repo, JsonObject contract) { return vertx.executeBlocking(() -> repo.validator(mainSchemaFile).validate(contract)); } + /** + * Validates additional contract files against the openapi schema. If validations fails, try to validate against the + * json schema specifications only. + * + * @param vertx The related Vert.x instance. + * @param repo The SchemaRepository to do the validations with. + * @param file The additional json contract to validate. + */ + public Future validateAdditionalContractFile(Vertx vertx, SchemaRepository repo, JsonObject file) { + return vertx.executeBlocking(() -> repo.validator(draft.getIdentifier()).validate(file)) + .compose(this::checkOutputUnit) + .mapEmpty(); + } + + private Future checkOutputUnit(OutputUnit ou) { + try { + ou.checkValidity(); + return Future.succeededFuture(); + } catch (JsonSchemaValidationException e) { + return Future.failedFuture(e); + } + } + public Future resolve(Vertx vertx, SchemaRepository repo, JsonObject contract) { return vertx.executeBlocking(() -> { - JsonSchema schema =JsonSchema.of(contract); + JsonSchema schema = JsonSchema.of(contract); repo.dereference(schema); return repo.resolve(contract); }); diff --git a/src/test/java/io/vertx/tests/contract/OpenAPIContractTest.java b/src/test/java/io/vertx/tests/contract/OpenAPIContractTest.java index d37e8b9..bdfe9f2 100644 --- a/src/test/java/io/vertx/tests/contract/OpenAPIContractTest.java +++ b/src/test/java/io/vertx/tests/contract/OpenAPIContractTest.java @@ -13,6 +13,7 @@ package io.vertx.tests.contract; import com.google.common.collect.ImmutableMap; +import io.vertx.core.Future; import io.vertx.core.Vertx; import io.vertx.core.buffer.Buffer; import io.vertx.core.json.JsonObject; @@ -38,6 +39,7 @@ import static com.google.common.truth.Truth.assertThat; import static io.vertx.tests.ResourceHelper.getRelatedTestResourcePath; import static io.vertx.tests.ResourceHelper.loadJson; +import static org.junit.jupiter.api.Assertions.assertTrue; @ExtendWith(VertxExtension.class) class OpenAPIContractTest { @@ -82,7 +84,7 @@ void testFromWithPath(String path, JsonObject expected, Vertx vertx, VertxTestCo @Timeout(value = 2, timeUnit = TimeUnit.SECONDS) @MethodSource void testFromWithPathAndAdditionalContractFiles(String path, Map additionalFiles, JsonObject expected, - Vertx vertx, VertxTestContext testContext) { + Vertx vertx, VertxTestContext testContext) { OpenAPIContract.from(vertx, path, additionalFiles) .onComplete(testContext.succeeding(contract -> testContext.verify(() -> { assertThat(contract.getRawContract()).isEqualTo(expected); @@ -126,7 +128,8 @@ void testInvalidAdditionalSpecFiles(Vertx vertx, VertxTestContext testContext) { .onComplete(testContext.failing(t -> testContext.verify(() -> { assertThat(t).isInstanceOf(OpenAPIContractException.class); String expectedErrorMessage = - "The passed OpenAPI contract is invalid: Found issue in specification for reference: https://example.com/petstore"; + "The passed OpenAPI contract is invalid: Found issue in specification for reference: " + + "Can't resolve 'https://example.com/petstore#/components/schemas/Pet', only internal refs are supported."; assertThat(t).hasMessageThat().isEqualTo(expectedErrorMessage); testContext.completeNow(); }))); @@ -152,4 +155,65 @@ void testSplitSpec(Vertx vertx, VertxTestContext testContext) { testContext.completeNow(); }))); } + + @Test + @Timeout(value = 2, timeUnit = TimeUnit.SECONDS) + void testValidJsonSchemaProvidedAsAdditionalSpecFiles(Vertx vertx, VertxTestContext testContext) { + Path resourcePath = getRelatedTestResourcePath(OpenAPIContractTest.class).resolve("split"); + JsonObject contract = loadJson(vertx, resourcePath.resolve("petstore.json")); + JsonObject invalidComponents = loadJson(vertx, resourcePath.resolve("validJsonSchemaComponents.json")); + JsonObject validComponents = loadJson(vertx, resourcePath.resolve("components.json")); + + Map additionalValidSpecFiles = ImmutableMap.of("https://example.com/petstore", validComponents); + Map additionalInvalidSpecFiles = ImmutableMap.of("https://example.com/petstore", invalidComponents); + + OpenAPIContract.from(vertx, contract.copy(), additionalValidSpecFiles) + .compose(validResp -> Future.succeededFuture(validResp.getRawContract())) + .onSuccess(validJsonRef -> OpenAPIContract.from(vertx, contract.copy(), additionalInvalidSpecFiles) + .onSuccess(splitResp -> testContext.verify(() -> { + assertThat(splitResp.getRawContract()).isEqualTo(validJsonRef); + testContext.completeNow(); + })) + .onFailure(testContext::failNow)) + .onFailure(testContext::failNow); + } + + @Test + @Timeout(value = 2, timeUnit = TimeUnit.SECONDS) + void testMalformedJsonSchemaProvidedAsAdditionalSpecFiles(Vertx vertx, VertxTestContext testContext) { + Path resourcePath = getRelatedTestResourcePath(OpenAPIContractTest.class).resolve("split"); + JsonObject contract = loadJson(vertx, resourcePath.resolve("petstore.json")); + JsonObject malformedComponents = loadJson(vertx, resourcePath.resolve("malformedComponents.json")); + + Map additionalMalformedSpecFiles = ImmutableMap.of("https://example.com/petstore", malformedComponents); + + OpenAPIContract.from(vertx, contract.copy(), additionalMalformedSpecFiles) + .onComplete(handler -> testContext.verify(() -> { + assertTrue(handler.failed()); + assertThat(handler.cause()).isInstanceOf(OpenAPIContractException.class); + assertThat(handler.cause()).hasMessageThat() + .isEqualTo("The passed OpenAPI contract is invalid: Found issue in specification for reference:" + + " -1 is less than 0"); + testContext.completeNow(); + })); + } + + @Test + @Timeout(value = 2, timeUnit = TimeUnit.SECONDS) + public void testAdditionalSchemaFiles(Vertx vertx, VertxTestContext testContext) { + Path resourcePath = getRelatedTestResourcePath(OpenAPIContractTest.class).resolve("additional_schema_files"); + Path contractPath = resourcePath.resolve("openapi.yaml"); + Path componentsPath = resourcePath.resolve("name.yaml"); + JsonObject dereferenced = loadJson(vertx, resourcePath.resolve("dereferenced.json")); + + Map additionalSpecFiles = ImmutableMap.of("https://schemas/Name.yaml", componentsPath.toString()); + OpenAPIContract.from(vertx, contractPath.toString(), additionalSpecFiles) + .onComplete(testContext.succeeding(c -> { + testContext.verify(() -> { + assertThat(c.getRawContract().toString()).isEqualTo(dereferenced.toString()); + testContext.completeNow(); + }); + })); + } + } diff --git a/src/test/java/io/vertx/tests/contract/OpenAPIVersionTest.java b/src/test/java/io/vertx/tests/contract/OpenAPIVersionTest.java index d5f36ac..940f9e3 100644 --- a/src/test/java/io/vertx/tests/contract/OpenAPIVersionTest.java +++ b/src/test/java/io/vertx/tests/contract/OpenAPIVersionTest.java @@ -15,6 +15,7 @@ import io.vertx.core.Vertx; import io.vertx.core.json.JsonObject; import io.vertx.json.schema.JsonSchema; +import io.vertx.json.schema.JsonSchemaValidationException; import io.vertx.json.schema.OutputUnit; import io.vertx.json.schema.SchemaRepository; import io.vertx.junit5.Timeout; @@ -43,6 +44,8 @@ import static io.vertx.openapi.impl.Utils.EMPTY_JSON_OBJECT; import static io.vertx.openapi.contract.OpenAPIVersion.V3_0; import static io.vertx.openapi.contract.OpenAPIVersion.V3_1; +import static io.vertx.tests.ResourceHelper.getRelatedTestResourcePath; +import static io.vertx.tests.ResourceHelper.loadJson; import static java.util.concurrent.TimeUnit.SECONDS; import static org.junit.jupiter.api.Assertions.assertThrows; @@ -58,7 +61,7 @@ private static Stream provideVersionAndSpec() { } private static Stream provideVersionAndInvalidSpec() { - Path basePath = ResourceHelper.getRelatedTestResourcePath(OpenAPIVersionTest.class); + Path basePath = getRelatedTestResourcePath(OpenAPIVersionTest.class); Function> buildValidator = expectedString -> ou -> { String error = ou.getErrors().stream().map(OutputUnit::getError).collect(Collectors.joining()); @@ -75,9 +78,9 @@ private static Stream provideVersionAndInvalidSpec() { @ParameterizedTest(name = "{index} should validate a contract against OpenAPI version {0}") @MethodSource(value = "provideVersionAndSpec") @Timeout(value = 2, timeUnit = SECONDS) - void testValidate(OpenAPIVersion version, Path contractFile, Vertx vertx, VertxTestContext testContext) { + void validateContractTest(OpenAPIVersion version, Path contractFile, Vertx vertx, VertxTestContext testContext) { JsonObject contract = vertx.fileSystem().readFileBlocking(contractFile.toString()).toJsonObject(); - version.getRepository(vertx, DUMMY_BASE_URI).compose(repo -> version.validate(vertx, repo, contract)) + version.getRepository(vertx, DUMMY_BASE_URI).compose(repo -> version.validateContract(vertx, repo, contract)) .onComplete(testContext.succeeding(res -> { testContext.verify(() -> assertThat(res.getValid()).isTrue()); testContext.completeNow(); @@ -87,10 +90,10 @@ void testValidate(OpenAPIVersion version, Path contractFile, Vertx vertx, VertxT @ParameterizedTest(name = "{index} should validate an invalid contract against OpenAPI version {0} and find errors") @MethodSource(value = "provideVersionAndInvalidSpec") @Timeout(value = 2, timeUnit = SECONDS) - void testValidateError(OpenAPIVersion version, Path contractFile, Consumer validator, Vertx vertx, - VertxTestContext testContext) { + void validateContractTestError(OpenAPIVersion version, Path contractFile, Consumer validator, Vertx vertx, + VertxTestContext testContext) { JsonObject contract = vertx.fileSystem().readFileBlocking(contractFile.toString()).toJsonObject(); - version.getRepository(vertx, DUMMY_BASE_URI).compose(repo -> version.validate(vertx, repo, contract)) + version.getRepository(vertx, DUMMY_BASE_URI).compose(repo -> version.validateContract(vertx, repo, contract)) .onComplete(testContext.succeeding(res -> { testContext.verify(() -> validator.accept(res)); testContext.completeNow(); @@ -145,4 +148,25 @@ void testFromSpecException() { assertThrows(OpenAPIContractException.class, () -> OpenAPIVersion.fromContract(unsupportedContract), expectedUnsupportedMsg); } + @ParameterizedTest(name = "{index} should be able to validate additional files against the json schema for {0}") + @EnumSource(OpenAPIVersion.class) + @Timeout(value = 2, timeUnit = SECONDS) + public void testValidationOfAdditionalSchemaFiles(OpenAPIVersion version, Vertx vertx, VertxTestContext testContext) { + Path path = getRelatedTestResourcePath(OpenAPIVersionTest.class).resolve("split"); + JsonObject validJsonSchema = loadJson(vertx, path.resolve("validJsonSchemaComponents.json")); + JsonObject malformedJsonSchema = loadJson(vertx, path.resolve("malformedComponents.json")); + + + version.getRepository(vertx, "https://vertx.io") + .onSuccess(repository -> version.validateAdditionalContractFile(vertx, repository, validJsonSchema) + .onFailure(testContext::failNow) + .onSuccess(ignored -> version.validateAdditionalContractFile(vertx, repository, malformedJsonSchema) + .onComplete(handler -> testContext.verify(() -> { + assertThat(handler.failed()).isTrue(); + assertThat(handler.cause()).isInstanceOf(JsonSchemaValidationException.class); + assertThat(handler.cause()).hasMessageThat().isEqualTo("-1 is less than 0"); + testContext.completeNow(); + })))); + } + } diff --git a/src/test/resources/io/vertx/tests/contract/additional_schema_files/dereferenced.json b/src/test/resources/io/vertx/tests/contract/additional_schema_files/dereferenced.json new file mode 100644 index 0000000..16763f2 --- /dev/null +++ b/src/test/resources/io/vertx/tests/contract/additional_schema_files/dereferenced.json @@ -0,0 +1,46 @@ +{ + "components": { + "schemas": { + "RequestBody": { + "type": "object", + "properties": { + "name": { + "$ref": "https://schemas/Name.yaml" + } + } + } + } + }, + "openapi": "3.1.0", + "paths": { + "/v1/post": { + "post": { + "summary": "Some POST request", + "requestBody": { + "required": true, + "content": { + "application/json": { + "schema": { + "$ref": "app:///#/components/schemas/RequestBody" + } + } + } + }, + "operationId": "postBody", + "responses": { + "200": { + "description": "Success" + }, + "default": { + "description": "An unexpected error occurred" + } + } + } + } + }, + "info": { + "title": "My Service", + "version": "1.0.0" + }, + "tags": [] +} diff --git a/src/test/resources/io/vertx/tests/contract/additional_schema_files/name.yaml b/src/test/resources/io/vertx/tests/contract/additional_schema_files/name.yaml new file mode 100644 index 0000000..aeeee41 --- /dev/null +++ b/src/test/resources/io/vertx/tests/contract/additional_schema_files/name.yaml @@ -0,0 +1,5 @@ +$schema: https://spec.openapis.org/oas/3.1/dialect/base +description: A case-insensitive string of 1-255 characters, serving as a name (unique identifier) +type: string +minLength: 1 +maxLength: 255 diff --git a/src/test/resources/io/vertx/tests/contract/additional_schema_files/openapi.yaml b/src/test/resources/io/vertx/tests/contract/additional_schema_files/openapi.yaml new file mode 100644 index 0000000..c5d309b --- /dev/null +++ b/src/test/resources/io/vertx/tests/contract/additional_schema_files/openapi.yaml @@ -0,0 +1,29 @@ +openapi: 3.1.0 +info: + title: My Service + version: 1.0.0 +tags: [] +paths: + /v1/post: + post: + summary: Some POST request + operationId: postBody + requestBody: + required: true + content: + application/json: + schema: + $ref: '#/components/schemas/RequestBody' + responses: + 200: + description: Success + default: + description: An unexpected error occurred +components: + schemas: + RequestBody: + type: object + properties: + name: + description: The unique name of the object + $ref: 'https://schemas/Name.yaml' diff --git a/src/test/resources/io/vertx/tests/contract/split/malformedComponents.json b/src/test/resources/io/vertx/tests/contract/split/malformedComponents.json new file mode 100644 index 0000000..964f7d2 --- /dev/null +++ b/src/test/resources/io/vertx/tests/contract/split/malformedComponents.json @@ -0,0 +1,6 @@ +{ + "title": "This is an invalid json schema", + "description": "Max length cannot be negative", + "type": "string", + "maxLength": -1 +} diff --git a/src/test/resources/io/vertx/tests/contract/split/validJsonSchemaComponents.json b/src/test/resources/io/vertx/tests/contract/split/validJsonSchemaComponents.json new file mode 100644 index 0000000..c105478 --- /dev/null +++ b/src/test/resources/io/vertx/tests/contract/split/validJsonSchemaComponents.json @@ -0,0 +1,51 @@ +{ + "$id": "petstore", + "openapi": "3.1.0", + "info": { + "version": "1.0.0", + "title": "Swagger Petstore", + "license": { + "identifier": "MIT", + "name": "MIT License" + } + }, + "components": { + "schemas": { + "Pet": { + "type": "object", + "required": [ + "id", + "name" + ], + "properties": { + "id": { + "type": "integer", + "format": "int64" + }, + "name": { + "type": "string" + }, + "tag": { + "type": "string" + } + } + }, + "Error": { + "type": "object", + "required": [ + "code", + "message" + ], + "properties": { + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + } + } + } + } + } +} From 3b4d46e6e10be0f0e1627dffbd115505d7029182 Mon Sep 17 00:00:00 2001 From: Gerrett Date: Sat, 3 Aug 2024 16:51:13 -0500 Subject: [PATCH 3/3] Fixing accidently whitespace changes. Signed-off-by: Gerrett --- .../io/vertx/openapi/validation/SchemaValidationException.java | 1 - .../io/vertx/tests/validation/SchemaValidationExceptionTest.java | 1 + 2 files changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/io/vertx/openapi/validation/SchemaValidationException.java b/src/main/java/io/vertx/openapi/validation/SchemaValidationException.java index fddbb50..6454ca4 100644 --- a/src/main/java/io/vertx/openapi/validation/SchemaValidationException.java +++ b/src/main/java/io/vertx/openapi/validation/SchemaValidationException.java @@ -52,7 +52,6 @@ public static SchemaValidationException createInvalidValueResponseBody(OutputUni return new SchemaValidationException(msg, INVALID_VALUE, outputUnit, cause); } - public static SchemaValidationException createMissingValueRequestBody(OutputUnit outputUnit, JsonSchemaValidationException cause) { String msg = String.format("The value of the request body is missing. Reason: %s", extractReason(outputUnit)); diff --git a/src/test/java/io/vertx/tests/validation/SchemaValidationExceptionTest.java b/src/test/java/io/vertx/tests/validation/SchemaValidationExceptionTest.java index 0b84732..a4b3190 100644 --- a/src/test/java/io/vertx/tests/validation/SchemaValidationExceptionTest.java +++ b/src/test/java/io/vertx/tests/validation/SchemaValidationExceptionTest.java @@ -41,6 +41,7 @@ class SchemaValidationExceptionTest { "keywordLocation", "error", OutputErrorType.INVALID_VALUE); private static final OutputUnit DUMMY_OUTPUT_UNIT = new OutputUnit("instanceLocation2", "absoluteKeywordLocation2", "keywordLocation2", "error2", OutputErrorType.MISSING_VALUE); + private static final OutputUnit DUMMY_OUTPUT_UNIT_INVALID = new OutputUnit("instanceLocation2", "absoluteKeywordLocation2", "keywordLocation2", "error2", OutputErrorType.INVALID_VALUE);