public void ResponseMustHaveADescription()
        {
            var openApiDocument = new OpenApiDocument();

            openApiDocument.Info = new OpenApiInfo()
            {
                Title   = "foo",
                Version = "1.2.2"
            };
            openApiDocument.Paths.Add(
                "/test",
                new OpenApiPathItem
            {
                Operations =
                {
                    [OperationType.Get] = new OpenApiOperation
                        {
                        Responses =
                        {
                        ["200"] = new OpenApiResponse()
                        }
                        }
                }
            });

            var validator = new OpenApiValidator();
            var walker    = new OpenApiWalker(validator);

            walker.Walk(openApiDocument);

            validator.Errors.ShouldBeEquivalentTo(
                new List <OpenApiError>
            {
                new OpenApiValidatorError(nameof(OpenApiResponseRules.ResponseRequiredFields), "#/paths/~1test/get/responses/200/description",
                                          String.Format(SRResource.Validation_FieldIsRequired, "description", "response"))
            });
        }
        public void ValidateDescriptionIsRequiredInResponse()
        {
            // Arrange
            IEnumerable <ValidationError> errors;
            OpenApiResponse response = new OpenApiResponse();

            // Act
            var validator = new OpenApiValidator();
            var walker    = new OpenApiWalker(validator);

            walker.Walk(response);

            errors = validator.Errors;
            bool result = !errors.Any();

            // Assert
            Assert.False(result);
            Assert.NotNull(errors);
            ValidationError error = Assert.Single(errors);

            Assert.Equal(String.Format(SRResource.Validation_FieldIsRequired, "description", "response"), error.ErrorMessage);
            Assert.Equal(ErrorReason.Required, error.ErrorCode);
            Assert.Equal("#/description", error.ErrorPath);
        }
        public void ValidateExampleShouldNotHaveDataTypeMismatchForSimpleSchema()
        {
            // Arrange
            IEnumerable <OpenApiError> errors;
            var parameter = new OpenApiParameter()
            {
                Name     = "parameter1",
                In       = ParameterLocation.Path,
                Required = true,
                Example  = new OpenApiInteger(55),
                Schema   = new OpenApiSchema()
                {
                    Type = "string",
                }
            };

            // Act
            var validator = new OpenApiValidator(ValidationRuleSet.GetDefaultRuleSet());
            var walker    = new OpenApiWalker(validator);

            walker.Walk(parameter);

            errors = validator.Errors;
            bool result = !errors.Any();

            // Assert
            result.Should().BeFalse();
            errors.Select(e => e.Message).Should().BeEquivalentTo(new[]
            {
                RuleHelpers.DataTypeMismatchedErrorMessage
            });
            errors.Select(e => e.Pointer).Should().BeEquivalentTo(new[]
            {
                "#/example",
            });
        }
        public void ValidateExampleShouldNotHaveDataTypeMismatchForSimpleSchema()
        {
            // Arrange
            IEnumerable <OpenApiError> errors;
            var mediaType = new OpenApiMediaType()
            {
                Example = new OpenApiInteger(55),
                Schema  = new OpenApiSchema()
                {
                    Type = "string",
                }
            };

            // Act
            var ruleset = ValidationRuleSet.GetDefaultRuleSet();

            ruleset.Add(OpenApiMediaTypeRules.MediaTypeMismatchedDataType);
            var validator = new OpenApiValidator(ruleset);
            var walker    = new OpenApiWalker(validator);

            walker.Walk(mediaType);

            errors = validator.Errors;
            bool result = !errors.Any();

            // Assert
            result.Should().BeFalse();
            errors.Select(e => e.Message).Should().BeEquivalentTo(new[]
            {
                RuleHelpers.DataTypeMismatchedErrorMessage
            });
            errors.Select(e => e.Pointer).Should().BeEquivalentTo(new[]
            {
                "#/example",
            });
        }
        public void ValidateDefaultShouldNotHaveDataTypeMismatchForComplexSchema()
        {
            // Arrange
            IEnumerable <OpenApiError> errors;
            var schema = new OpenApiSchema()
            {
                Type       = "object",
                Properties =
                {
                    ["property1"] = new OpenApiSchema()
                            {
                            Type  = "array",
                            Items = new OpenApiSchema()
                            {
                            Type   = "integer",
                            Format = "int64"
                            }
                            },
                    ["property2"] = new OpenApiSchema()
                            {
                            Type  = "array",
                            Items = new OpenApiSchema()
                            {
                            Type = "object",
                            AdditionalProperties = new OpenApiSchema()
                            {
                            Type = "boolean"
                            }
                            }
                            },
                    ["property3"] = new OpenApiSchema()
                            {
                            Type   = "string",
                            Format = "password"
                            },
                    ["property4"] = new OpenApiSchema()
                            {
                            Type = "string"
                            }
                },
                Default = new OpenApiObject()
                {
                    ["property1"] = new OpenApiArray()
                    {
                        new OpenApiInteger(12),
                        new OpenApiLong(13),
                        new OpenApiString("1"),
                    },
                    ["property2"] = new OpenApiArray()
                    {
                        new OpenApiInteger(2),
                        new OpenApiObject()
                        {
                            ["x"] = new OpenApiBoolean(true),
                            ["y"] = new OpenApiBoolean(false),
                            ["z"] = new OpenApiString("1234"),
                        }
                    },
                    ["property3"] = new OpenApiPassword("123"),
                    ["property4"] = new OpenApiDateTime(DateTime.UtcNow)
                }
            };

            // Act
            var validator = new OpenApiValidator(ValidationRuleSet.GetDefaultRuleSet());
            var walker    = new OpenApiWalker(validator);

            walker.Walk(schema);

            errors = validator.Errors;
            bool result = !errors.Any();

            // Assert
            result.Should().BeFalse();
            errors.Select(e => e.Message).Should().BeEquivalentTo(new[]
            {
                RuleHelpers.DataTypeMismatchedErrorMessage,
                RuleHelpers.DataTypeMismatchedErrorMessage,
                RuleHelpers.DataTypeMismatchedErrorMessage,
                RuleHelpers.DataTypeMismatchedErrorMessage,
                RuleHelpers.DataTypeMismatchedErrorMessage,
            });
            errors.Select(e => e.Pointer).Should().BeEquivalentTo(new[]
            {
                "#/default/property1/0",
                "#/default/property1/2",
                "#/default/property2/0",
                "#/default/property2/1/z",
                "#/default/property4",
            });
        }
Beispiel #6
0
        public void ValidateExamplesShouldNotHaveDataTypeMismatchForSimpleSchema()
        {
            // Arrange
            IEnumerable <OpenApiError> errors;

            var parameter = new OpenApiParameter()
            {
                Name     = "parameter1",
                In       = ParameterLocation.Path,
                Required = true,
                Schema   = new OpenApiSchema()
                {
                    Type = "object",
                    AdditionalProperties = new OpenApiSchema()
                    {
                        Type = "integer",
                    }
                },
                Examples =
                {
                    ["example0"] = new OpenApiExample()
                        {
                        Value = new OpenApiString("1"),
                        },
                    ["example1"] = new OpenApiExample()
                        {
                        Value = new OpenApiObject()
                        {
                        ["x"] = new OpenApiInteger(2),
                        ["y"] = new OpenApiString("20"),
                        ["z"] = new OpenApiString("200")
                        }
                        },
                    ["example2"] = new OpenApiExample()
                        {
                        Value =
                            new OpenApiArray()
                        {
                        new OpenApiInteger(3)
                        }
                        },
                    ["example3"] = new OpenApiExample()
                        {
                        Value = new OpenApiObject()
                        {
                        ["x"] = new OpenApiInteger(4),
                        ["y"] = new OpenApiInteger(40),
                        }
                        },
                }
            };

            // Act
            var validator = new OpenApiValidator(ValidationRuleSet.GetDefaultRuleSet());

            validator.Enter("{parameter1}");
            var walker = new OpenApiWalker(validator);

            walker.Walk(parameter);

            errors = validator.Errors;
            bool result = !errors.Any();

            // Assert
            result.Should().BeFalse();
            errors.Select(e => e.Message).Should().BeEquivalentTo(new[]
            {
                RuleHelpers.DataTypeMismatchedErrorMessage,
                RuleHelpers.DataTypeMismatchedErrorMessage,
                RuleHelpers.DataTypeMismatchedErrorMessage,
            });
            errors.Select(e => e.Pointer).Should().BeEquivalentTo(new[]
            {
                // #enum/0 is not an error since the spec allows
                // representing an object using a string.
                "#/{parameter1}/examples/example1/value/y",
                "#/{parameter1}/examples/example1/value/z",
                "#/{parameter1}/examples/example2/value"
            });
        }
        public void ValidateAnyOfCompositeSchemaMustContainPropertySpecifiedInTheDiscriminator()
        {
            IEnumerable <OpenApiError> errors;
            var schema = new OpenApiSchema
            {
                Type  = "object",
                AnyOf = new List <OpenApiSchema>
                {
                    new OpenApiSchema
                    {
                        Type       = "object",
                        Properties =
                        {
                            ["property1"] = new OpenApiSchema()
                            {
                            Type = "integer", Format = "int64"
                            },
                            ["property2"] = new OpenApiSchema()
                            {
                            Type = "string"
                            }
                        },
                        Reference = new OpenApiReference {
                            Id = "schema1"
                        }
                    },
                    new OpenApiSchema
                    {
                        Type       = "object",
                        Properties =
                        {
                            ["property1"] = new OpenApiSchema()
                            {
                            Type = "integer", Format = "int64"
                            },
                        },
                        Reference = new OpenApiReference {
                            Id = "schema2"
                        }
                    }
                },
                Discriminator = new OpenApiDiscriminator
                {
                    PropertyName = "property2"
                }
            };

            // Act
            var validator = new OpenApiValidator(ValidationRuleSet.GetDefaultRuleSet());
            var walker    = new OpenApiWalker(validator);

            walker.Walk(schema);

            errors = validator.Errors;
            bool result = !errors.Any();

            // Assert
            result.Should().BeFalse();
            errors.ShouldAllBeEquivalentTo(new List <OpenApiValidatorError>
            {
                new OpenApiValidatorError(nameof(OpenApiSchemaRules.ValidateAnyOfDiscriminator), "#/anyOf",
                                          string.Format(SRResource.Validation_CompositeSchemaRequiredFieldListMustContainThePropertySpecifiedInTheDiscriminator,
                                                        "schema1", "property2")),

                new OpenApiValidatorError(nameof(OpenApiSchemaRules.ValidateAnyOfDiscriminator), "#/anyOf",
                                          string.Format(SRResource.Validation_CompositeSchemaMustContainPropertySpecifiedInTheDiscriminator,
                                                        "schema2", "property2")),

                new OpenApiValidatorError(nameof(OpenApiSchemaRules.ValidateAnyOfDiscriminator), "#/anyOf",
                                          string.Format(SRResource.Validation_CompositeSchemaRequiredFieldListMustContainThePropertySpecifiedInTheDiscriminator,
                                                        "schema2", "property2")),
            });
        }