public void ServersShouldBeReferencedByIndex()
        {
            var openApiDocument = new OpenApiDocument
            {
                Info = new OpenApiInfo()
                {
                    Title   = "foo",
                    Version = "1.2.2"
                },
                Servers = new List <OpenApiServer> {
                    new OpenApiServer
                    {
                        Url = "http://example.org"
                    },
                    new OpenApiServer
                    {
                    },
                },
                Paths = new OpenApiPaths()
            };

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

            walker.Walk(openApiDocument);

            validator.Errors.Should().BeEquivalentTo(
                new List <OpenApiError>
            {
                new OpenApiValidatorError(nameof(OpenApiServerRules.ServerRequiredFields), "#/servers/1/url",
                                          String.Format(SRResource.Validation_FieldIsRequired, "url", "server"))
            });
        }
        public void NewValidationRulesShouldBeInTheRuleSetExceptBaselinedExceptionRules()
        {
            var validationRules = new Dictionary <object, string>();
            var items           = typeof(ValidationRules).GetFields().Select(f => new KeyValuePair <object, string>(f.GetValue(null), f.Name));

            foreach (var item in items)
            {
                validationRules.Add(item.Key, item.Value);
            }

            var unFoundValidationRules = new List <object>();

            foreach (var ruleSet in ValidationRuleSet.GetEdmModelRuleSet(new Version(4, 0)))
            {
                if (validationRules.ContainsKey(ruleSet))
                {
                    validationRules.Remove(ruleSet);
                }
                else
                {
                    unFoundValidationRules.Add(validationRules);
                }
            }

            unFoundValidationRules.Should().HaveCount(0);
            validationRules.ToList().Should().HaveCount(0);
        }
Esempio n. 3
0
        public void Evaluate()
        {
            IValidationRuleSetDescriptor ruleSetDescriptor = this.mockery.NewMock <IValidationRuleSetDescriptor>();

            Expect.On(ruleSetDescriptor).GetProperty("Factory").Will(Return.Value(this.validationFactory));

            IRuleSet <IValidationRule> ruleSet = new ValidationRuleSet {
                this.mockery.NewMock <IValidationRule>()
            };

            Expect.Once.On(this.defaultRulesProvider).Method("GetRules").With(ruleSetDescriptor).Will(Return.Value(ruleSet));
            Expect.Once.On(this.pluginRulesProvider).Method("GetRules").With(ruleSetDescriptor).Will(Return.Value(null));

            IValidationResult validationResult = this.mockery.NewMock <IValidationResult>();

            IValidationAggregator aggregator = this.mockery.NewMock <IValidationAggregator>();

            Stub.On(ruleSetDescriptor).GetProperty("Aggregator").Will(Return.Value(aggregator));
            Stub.On(aggregator).Method("Aggregate").With(ruleSet, Is.Out).Will(
                Return.Value(validationResult),
                Return.OutValue(1, "log"));

            IValidationResult result = this.testee.Evaluate(ruleSetDescriptor);

            Assert.AreEqual(validationResult, result, "result of aggregator is not passed correctly as result of Evaluate.");
        }
Esempio n. 4
0
        public void ValidateExampleShouldNotHaveDataTypeMismatchForSimpleSchema()
        {
            // Arrange
            IEnumerable <OpenApiError> errors;
            var header = new OpenApiHeader()
            {
                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(header);

            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",
            });
        }
Esempio n. 5
0
        public void NewValidationRulesShouldBeInTheRuleSetExceptBaselinedExceptionRules()
        {
            var validationRules = new Dictionary <object, string>();
            var items           = typeof(ValidationRules).GetFields().Where(f =>
                                                                            f.Name != "NavigationPropertyEntityMustNotIndirectlyContainItself" &&
                                                                            f.Name != "EntityTypeKeyMissingOnEntityType" &&
                                                                            f.Name != "VocabularyAnnotationTargetAllowedApplyToElement")
                                  .Select(f => new KeyValuePair <object, string>(f.GetValue(null), f.Name));

            foreach (var item in items)
            {
                validationRules.Add(item.Key, item.Value);
            }

            var unFoundValidationRules = new List <object>();

            foreach (var ruleSet in ValidationRuleSet.GetEdmModelRuleSet(new Version(4, 0)))
            {
                if (validationRules.ContainsKey(ruleSet))
                {
                    validationRules.Remove(ruleSet);
                }
                else
                {
                    unFoundValidationRules.Add(validationRules);
                }
            }

            unFoundValidationRules.Should().HaveCount(0);
            validationRules.ToList().Should().HaveCount(0);
        }
Esempio n. 6
0
		public static bool Validate(this IEdmModel root, ValidationRuleSet ruleSet, out IEnumerable<EdmError> errors)
		{
			EdmUtil.CheckArgumentNull<IEdmModel>(root, "root");
			EdmUtil.CheckArgumentNull<ValidationRuleSet>(ruleSet, "ruleSet");
			errors = InterfaceValidator.ValidateModelStructureAndSemantics(root, ruleSet);
			return errors.FirstOrDefault<EdmError>() == null;
		}
        public void ValidateExampleAndDefaultShouldNotHaveDataTypeMismatchForSimpleSchema()
        {
            // Arrange
            IEnumerable <OpenApiError> errors;
            var schema = new OpenApiSchema()
            {
                Example = new OpenApiLong(55),
                Default = new OpenApiPassword("1234"),
                Type    = "string",
            };

            // 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
            });
            errors.Select(e => e.Pointer).Should().BeEquivalentTo(new[]
            {
                "#/default",
                "#/example",
            });
        }
Esempio n. 8
0
        public void PathParameterInThePathShouldBeOk()
        {
            // Arrange
            IEnumerable <OpenApiError> errors;

            var parameter = new OpenApiParameter()
            {
                Name     = "parameter1",
                In       = ParameterLocation.Path,
                Required = true,
                Schema   = new OpenApiSchema()
                {
                    Type = "string",
                }
            };

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

            validator.Enter("paths");
            validator.Enter("/{parameter1}");
            validator.Enter("get");
            validator.Enter("parameters");
            validator.Enter("1");

            var walker = new OpenApiWalker(validator);

            walker.Walk(parameter);

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

            // Assert
            result.Should().BeFalse();
        }
Esempio n. 9
0
        /// <summary>
        /// Default constructor.
        /// </summary>
        protected ApplicationComponent()
        {
            _exitCode = ApplicationComponentExitCode.None;                // default exit code

            // create default validation rule set containing rules for this type
            _validation = new ValidationRuleSet(ValidationCache.Instance.GetRules(this.GetType()));
        }
        private static OpenApiDocument GetOpenApiDocument(string url)
        {
            HttpClient httpClient = CreateHttpClient();

            var response = httpClient.GetAsync(url)
                           .GetAwaiter().GetResult();

            if (!response.IsSuccessStatusCode)
            {
                throw new Exception("Failed to retrieve OpenApi document");
            }

            var stream = response.Content.ReadAsStreamAsync().GetAwaiter().GetResult();;

            var newrules = ValidationRuleSet.GetDefaultRuleSet().Rules
                           .Where(r => r.GetType() != typeof(ValidationRule <OpenApiSchema>)).ToList();


            var reader = new OpenApiStreamReader(new OpenApiReaderSettings()
            {
                RuleSet = new ValidationRuleSet(newrules)
            });
            var openApiDoc = reader.Read(stream, out var diagnostic);

            if (diagnostic.Errors.Count > 0)
            {
                throw new Exception("OpenApi document has errors : " + String.Join("\n", diagnostic.Errors));
            }
            return(openApiDoc);
        }
Esempio n. 11
0
        private string ConvertToOpenAPI(string text)
        {
            Stream stream = CreateStream(text);

            var document = new OpenApiStreamReader(new OpenApiReaderSettings
            {
                ReferenceResolution = ReferenceResolutionSetting.ResolveLocalReferences,
                RuleSet             = ValidationRuleSet.GetDefaultRuleSet()
            }
                                                   ).Read(stream, out var context);

            if (context.Errors.Any())
            {
                var errorReport = new StringBuilder();

                foreach (var error in context.Errors)
                {
                    errorReport.AppendLine(error.ToString());
                }

                throw new ConversionException(errorReport.ToString());
            }

            return(WriteContents(document));
        }
Esempio n. 12
0
        internal static void ValidateOpenApiDocument(string input)
        {
            if (input == null)
            {
                throw new ArgumentNullException("input");
            }

            var stream = GetStream(input);

            OpenApiDocument document;

            document = new OpenApiStreamReader(new OpenApiReaderSettings
            {
                RuleSet = ValidationRuleSet.GetDefaultRuleSet()
            }
                                               ).Read(stream, out var context);

            if (context.Errors.Count != 0)
            {
                foreach (var error in context.Errors)
                {
                    Console.WriteLine(error.ToString());
                }
            }

            var statsVisitor = new StatsVisitor();
            var walker       = new OpenApiWalker(statsVisitor);

            walker.Walk(document);

            Console.WriteLine(statsVisitor.GetStatisticsReport());
        }
Esempio n. 13
0
        public void ValidateExtensionNameStartsWithXDashInTag()
        {
            // Arrange
            IEnumerable <OpenApiError> errors;
            OpenApiTag tag = new OpenApiTag
            {
                Name = "tag"
            };

            tag.Extensions.Add("tagExt", new OpenApiString("value"));

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

            validator.Visit(tag as IOpenApiExtensible);
            errors = validator.Errors;
            bool result = !errors.Any();

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

            Assert.Equal(String.Format(SRResource.Validation_ExtensionNameMustBeginWithXDash, "tagExt", "#/extensions"), error.Message);
        }
Esempio n. 14
0
        public void ValidateRequiredIsTrueWhenInIsPathInParameter()
        {
            // Arrange
            var parameter = new OpenApiParameter()
            {
                Name = "name",
                In   = ParameterLocation.Path
            };

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

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

            walker.Walk(parameter);
            var errors = validator.Errors;

            // Assert
            errors.Should().NotBeEmpty();
            errors.Select(e => e.Message).Should().BeEquivalentTo(new[]
            {
                "\"required\" must be true when parameter location is \"path\""
            });
        }
Esempio n. 15
0
        private void ValidateUsingEdmValidator(IEdmModel model, ValidationRuleSet ruleSet, IEnumerable <EdmError> expectedErrors)
        {
            IEnumerable <EdmError> actualErrors;

            model.Validate(ruleSet, out actualErrors);
            this.CompareErrors(actualErrors, expectedErrors);
        }
Esempio n. 16
0
        public void NewValidationRulesShouldBeInTheRuleSetExceptBaselinedExceptionRules()
        {
            var validationRules = new Dictionary <object, string>();
            var items           = typeof(ValidationRules).GetFields().Select(f => new KeyValuePair <object, string>(f.GetValue(null), f.Name));

            foreach (var item in items)
            {
                validationRules.Add(item.Key, item.Value);
            }

            var unFoundValidationRules = new List <object>();

            foreach (var ruleSet in ValidationRuleSet.GetEdmModelRuleSet(new Version(4, 0)))
            {
                if (validationRules.ContainsKey(ruleSet))
                {
                    validationRules.Remove(ruleSet);
                }
                else
                {
                    unFoundValidationRules.Add(validationRules);
                }
            }

            unFoundValidationRules.Should().HaveCount(0);

            // The 4 remaining rules are deprecated:
            // ComplexTypeMustContainProperties
            // OnlyEntityTypesCanBeOpen
            // ComplexTypeInvalidPolymorphicComplexType
            // ComplexTypeInvalidAbstractComplexType
            validationRules.ToList().Should().HaveCount(4);
        }
        public void ValidateKeyMustMatchRegularExpressionInComponents()
        {
            // Arrange
            const string key = "%@abc";

            OpenApiComponents components = new OpenApiComponents()
            {
                Responses = new Dictionary <string, OpenApiResponse>
                {
                    { key, new OpenApiResponse {
                          Description = "any"
                      } }
                }
            };

            var errors = components.Validate(ValidationRuleSet.GetDefaultRuleSet());

            // Act
            bool result = !errors.Any();


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

            Assert.Equal(String.Format(SRResource.Validation_ComponentsKeyMustMatchRegularExpr, key, "responses", OpenApiComponentsRules.KeyRegex.ToString()),
                         error.Message);
        }
Esempio n. 18
0
        internal static async void ValidateOpenApiDocument(string openapi, LogLevel loglevel)
        {
            if (string.IsNullOrEmpty(openapi))
            {
                throw new ArgumentNullException(nameof(openapi));
            }
            var logger = ConfigureLoggerInstance(loglevel);
            var stream = await GetStream(openapi, logger);

            OpenApiDocument document;

            logger.LogTrace("Parsing the OpenApi file");
            document = new OpenApiStreamReader(new OpenApiReaderSettings
            {
                RuleSet = ValidationRuleSet.GetDefaultRuleSet()
            }
                                               ).Read(stream, out var context);

            if (context.Errors.Count != 0)
            {
                foreach (var error in context.Errors)
                {
                    Console.WriteLine(error.ToString());
                }
            }

            var statsVisitor = new StatsVisitor();
            var walker       = new OpenApiWalker(statsVisitor);

            walker.Walk(document);

            logger.LogTrace("Finished walking through the OpenApi document. Generating a statistics report..");
            Console.WriteLine(statsVisitor.GetStatisticsReport());
        }
        public void ValidateEnumShouldNotHaveDataTypeMismatchForSimpleSchema()
        {
            // Arrange
            IEnumerable <OpenApiError> errors;
            var schema = new OpenApiSchema()
            {
                Enum =
                {
                    new OpenApiString("1"),
                    new OpenApiObject()
                    {
                        ["x"] = new OpenApiInteger(2),
                        ["y"] = new OpenApiString("20"),
                        ["z"] = new OpenApiString("200")
                    },
                    new OpenApiArray()
                    {
                        new OpenApiInteger(3)
                    },
                    new OpenApiObject()
                    {
                        ["x"] = new OpenApiInteger(4),
                        ["y"] = new OpenApiInteger(40),
                    },
                },
                Type = "object",
                AdditionalProperties = new OpenApiSchema()
                {
                    Type = "integer",
                }
            };

            // 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,
            });
            errors.Select(e => e.Pointer).Should().BeEquivalentTo(new[]
            {
                // #enum/0 is not an error since the spec allows
                // representing an object using a string.
                "#/enum/1/y",
                "#/enum/1/z",
                "#/enum/2"
            });
        }
        public OpenApiDocument Read(string text)
        {
            var document = new OpenApiStringReader(new OpenApiReaderSettings
            {
                ReferenceResolution = ReferenceResolutionSetting.ResolveLocalReferences,
                RuleSet             = ValidationRuleSet.GetDefaultRuleSet()
            }).Read(text, out var context);

            return(!_validator.IsValid(document) ? null : document);
        }
        /// <summary>
        /// Runs the OpenApiValidator against the OpenApiDocument object. Returns true if the document is valid, false otherwise
        /// </summary>
        /// <param name="doc">The OpenApiDocument to test against</param>
        /// <param name="context"></param>
        /// <returns></returns>
        private void IsValidOpenAPIDocument(OpenApiDocument doc, CustomContext context)
        {
            var openApiValidator = new OpenApiValidator(ValidationRuleSet.GetDefaultRuleSet());

            openApiValidator.Visit(doc);
            foreach (var error in openApiValidator.Errors)
            {
                context.AddFailure(error.Message);
            }
        }
Esempio n. 22
0
        protected void VerifySemanticValidation(IEdmModel testModel, ValidationRuleSet ruleset, IEnumerable <EdmError> expectedErrors)
        {
            // Compare the actual errors of the test models to the expected errors.
            IEnumerable <EdmError> actualErrors = null;
            var validationResult = testModel.Validate(ruleset, out actualErrors);

            Assert.IsTrue(actualErrors.Any() ? !validationResult : validationResult, "The return value of the Validate method does not match the reported validation errors.");
            this.CompareErrors(actualErrors, expectedErrors);

            // Compare the round-tripped immutable model through the CSDL serialized from the original test model against the expected errors.
            Func <EdmVersion> GetEdmVersionFromRuleSet = () =>
            {
                EdmVersion result = EdmVersion.Latest;
                foreach (var edmVersion in new EdmVersion[] { EdmVersion.V40 })
                {
                    var versionRuleSet = ValidationRuleSet.GetEdmModelRuleSet(toProductVersionlookup[edmVersion]);
                    if (versionRuleSet.Count() == ruleset.Count() && !ruleset.Except(versionRuleSet).Any())
                    {
                        result = edmVersion;
                        break;
                    }
                }
                return(result);
            };

            IEnumerable <EdmError> serializationErrors;
            var serializedCsdls = this.GetSerializerResult(testModel, GetEdmVersionFromRuleSet(), out serializationErrors).Select(n => XElement.Parse(n));

            if (!serializedCsdls.Any())
            {
                Assert.AreNotEqual(0, serializationErrors.Count(), "Empty models should have associated errors");
                return;
            }

            if (!actualErrors.Any())
            {
                // if the original test model is valid, the round-tripped model should be well-formed and valid.
                IEnumerable <EdmError> parserErrors = null;
                IEdmModel roundtrippedModel         = null;
                var       isWellformed = CsdlReader.TryParse(serializedCsdls.Select(e => e.CreateReader()), out roundtrippedModel, out parserErrors);
                Assert.IsTrue(isWellformed && !parserErrors.Any(), "The model from valid CSDLs should be generated back to well-formed CSDLs.");

                IEnumerable <EdmError> validationErrors = null;
                var isValid = roundtrippedModel.Validate(out validationErrors);
                Assert.IsTrue(!validationErrors.Any() && isValid, "The model from valid CSDLs should be generated back to valid CSDLs.");
            }
            else
            {
                // if the originl test model is not valid, the serializer should still generate CSDLs that parser can handle, but the round trip-ability is not guarantted.
                IEnumerable <EdmError> parserErrors = null;
                IEdmModel roundtrippedModel         = null;
                var       isWellformed = CsdlReader.TryParse(serializedCsdls.Select(e => e.CreateReader()), out roundtrippedModel, out parserErrors);
                Assert.IsTrue(isWellformed, "The parser cannot handle the CSDL that the serializer generated:" + Environment.NewLine + String.Join(Environment.NewLine, parserErrors));
            }
        }
Esempio n. 23
0
        private static void ValidateDocument(FileStream stream)
        {
            OpenApiStreamReader reader   = new();
            OpenApiDocument     document = reader.Read(stream, out OpenApiDiagnostic diagnostic);

            Assert.Empty(diagnostic.Errors);

            IEnumerable <OpenApiError> errors = document.Validate(ValidationRuleSet.GetDefaultRuleSet());

            Assert.Empty(errors);
        }
        public OpenApiDocument Read(FileInfo input)
        {
            using Stream stream = input.OpenRead();
            var document = new OpenApiStreamReader(new OpenApiReaderSettings
            {
                ReferenceResolution = ReferenceResolutionSetting.ResolveLocalReferences,
                RuleSet             = ValidationRuleSet.GetDefaultRuleSet()
            }
                                                   ).Read(stream, out var context);

            return(!_validator.IsValid(document) ? null : document);
        }
        public void DefaultRuleSetReturnsTheCorrectRules()
        {
            // Arrange
            var ruleSet = new ValidationRuleSet();

            // Act
            var rules = ruleSet.Rules;

            // Assert
            Assert.NotNull(rules);
            Assert.Empty(rules);
        }
Esempio n. 26
0
    public OpenApiDocument Parse(string json)
    {
        var stream = CreateStream(json);
        var parsed = new OpenApiStreamReader(new OpenApiReaderSettings
        {
            ReferenceResolution = ReferenceResolutionSetting.ResolveLocalReferences,
            RuleSet             = ValidationRuleSet.GetDefaultRuleSet()
        }).Read(stream, out var openApiDiagnostic);

        Debug.Log("Successfully parsed API Description: " + parsed.Info.Title);
        return(parsed);
    }
Esempio n. 27
0
        public void TestEdmExpressionKindInterfaceCriticalKindValueUnexpectedOnlyModel()
        {
            var expectedErrors = new EdmLibTestErrors()
            {
                { null, null, EdmErrorCode.InterfaceCriticalKindValueUnexpected }
            };

            var model = InterfaceCriticalModelBuilder.EdmExpressionKindInterfaceCriticalKindValueUnexpectedOnlyModel();

            this.ValidateUsingEdmValidator(model, expectedErrors);
            this.ValidateUsingEdmValidator(model, EdmConstants.EdmVersion4, expectedErrors);
            this.ValidateUsingEdmValidator(model, ValidationRuleSet.GetEdmModelRuleSet(EdmConstants.EdmVersion4), expectedErrors);
        }
Esempio n. 28
0
        public void TestInterfaceCriticalPropertyValueMustNotBeNullUsingOperationParameterDeclaredTypeModel()
        {
            var expectedErrors = new EdmLibTestErrors()
            {
                { null, null, EdmErrorCode.InterfaceCriticalPropertyValueMustNotBeNull }
            };

            var model = InterfaceCriticalModelBuilder.InterfaceCriticalPropertyValueMustNotBeNullUsingOperationParameterDeclaredTypeModel();

            this.ValidateUsingEdmValidator(model, expectedErrors);
            this.ValidateUsingEdmValidator(model, EdmConstants.EdmVersion4, expectedErrors);
            this.ValidateUsingEdmValidator(model, ValidationRuleSet.GetEdmModelRuleSet(EdmConstants.EdmVersion4), expectedErrors);
        }
Esempio n. 29
0
        public void TestInterfaceCriticalKindValueMismatchOnlyUsingEnumTypeReferenceModel()
        {
            var expectedErrors = new EdmLibTestErrors()
            {
                { null, null, EdmErrorCode.InterfaceCriticalKindValueMismatch }
            };

            var model = InterfaceCriticalModelBuilder.InterfaceCriticalKindValueMismatchOnlyUsingEnumTypeReferenceModel();

            this.ValidateUsingEdmValidator(model, expectedErrors);
            this.ValidateUsingEdmValidator(model, EdmConstants.EdmVersion4, expectedErrors);
            this.ValidateUsingEdmValidator(model, ValidationRuleSet.GetEdmModelRuleSet(EdmConstants.EdmVersion4), expectedErrors);
        }
Esempio n. 30
0
        public void TestInterfaceCriticalEnumerableMustNotHaveNullElementsOnlyModel()
        {
            var expectedErrors = new EdmLibTestErrors()
            {
                { null, null, EdmErrorCode.InterfaceCriticalEnumerableMustNotHaveNullElements }
            };

            var model = InterfaceCriticalModelBuilder.InterfaceCriticalEnumerableMustNotHaveNullElementsOnlyModel();

            this.ValidateUsingEdmValidator(model, expectedErrors);
            this.ValidateUsingEdmValidator(model, EdmConstants.EdmVersion4, expectedErrors);
            this.ValidateUsingEdmValidator(model, ValidationRuleSet.GetEdmModelRuleSet(EdmConstants.EdmVersion4), expectedErrors);
        }
Esempio n. 31
0
        public void TestInterfaceCriticalPropertyValueMustNotBeNullCsdl()
        {
            var expectedErrors = new EdmLibTestErrors()
            {
                { null, null, EdmErrorCode.InterfaceCriticalPropertyValueMustNotBeNull }
            };

            var csdls = InterfaceCriticalModelBuilder.InterfaceCriticalPropertyValueMustNotBeNullOnlyCsdl();
            var model = this.GetParserResult(csdls);

            this.ValidateUsingEdmValidator(model, expectedErrors);
            this.ValidateUsingEdmValidator(model, EdmConstants.EdmVersion4, expectedErrors);
            this.ValidateUsingEdmValidator(model, ValidationRuleSet.GetEdmModelRuleSet(EdmConstants.EdmVersion4), expectedErrors);
        }
Esempio n. 32
0
 internal static void ValidateModel(IEdmModel model, Version edmSchemaVersion)
 {
     IEnumerable<EdmError> enumerable;
     ValidationRuleSet ruleSet = new ValidationRuleSet(ValidationRuleSet.GetEdmModelRuleSet(edmSchemaVersion).Except<ValidationRule>(excludedSchemaValidationRules).Concat<ValidationRule>(additionalSchemaValidationRules));
     model.Validate(ruleSet, out enumerable);
     if ((enumerable != null) && enumerable.Any<EdmError>())
     {
         StringBuilder builder = new StringBuilder();
         foreach (EdmError error in enumerable)
         {
             builder.AppendLine(error.ToString());
         }
         throw new DataServiceException(500, System.Data.Services.Strings.MetadataSerializer_ModelValidationErrors(builder.ToString()));
     }
 }
        public void AggregateARuleSetWithValidRulesResultsInAValidResult()
        {
            ValidationAggregator testee = new ValidationAggregator(this.validationFactory, false);

            IRuleSet<IValidationRule> ruleSet = new ValidationRuleSet
                                                    {
                                                        this.mockery.NewMock<IValidationRule>(),
                                                        this.mockery.NewMock<IValidationRule>()
                                                    };
            
            Expect.On(ruleSet[0]).Method("Evaluate").Will(Return.Value(new ValidationResult(true)));
            Expect.On(ruleSet[1]).Method("Evaluate").Will(Return.Value(new ValidationResult(true)));
            
            string logInfo;
            IValidationResult result = testee.Aggregate(ruleSet, out logInfo);

            Assert.IsTrue(result.Valid, "aggregated result has to be valid if all rules are valid.");
        }
Esempio n. 34
0
        /// <summary>
        /// Validates the given <paramref name="model"/>.
        /// </summary>
        /// <param name="model">The <see cref="IEdmModel"/> to check.</param>
        /// <param name="edmSchemaVersion">The EDM version to be used.</param>
        internal static void ValidateModel(IEdmModel model, Version edmSchemaVersion)
        {
            ValidationRuleSet ruleSet = ValidationRuleSet.GetEdmModelRuleSet(edmSchemaVersion);
            ValidationRuleSet ruleSetWithoutTypeNameChecks = new ValidationRuleSet(
                ruleSet.Except(excludedSchemaValidationRules).Concat(additionalSchemaValidationRules));

            IEnumerable<EdmError> validationErrors;
            model.Validate(ruleSetWithoutTypeNameChecks, out validationErrors);

            if (validationErrors != null && validationErrors.Any())
            {
                StringBuilder builder = new StringBuilder();
                foreach (EdmError validationError in validationErrors)
                {
                    builder.AppendLine(validationError.ToString());
                }

                throw new DataServiceException(500, Microsoft.OData.Service.Strings.MetadataSerializer_ModelValidationErrors(builder.ToString()));
            }
        }
        public void AggregateARuleSetWithInvalidRulesResultsInAnInvalidResult()
        {
            ValidationAggregator testee = new ValidationAggregator(this.validationFactory, false);

            IRuleSet<IValidationRule> ruleSet = new ValidationRuleSet
                                                    {
                                                        this.mockery.NewMock<IValidationRule>(),
                                                        this.mockery.NewMock<IValidationRule>()
                                                    };

            Expect.On(ruleSet[0]).Method("Evaluate").Will(Return.Value(new ValidationResult(true)));

            ValidationResult invalidResult = new ValidationResult(false);
            invalidResult.Violations.Add(new ValidationViolation("test"));
            Expect.On(ruleSet[1]).Method("Evaluate").Will(Return.Value(invalidResult));

            string logInfo;
            IValidationResult result = testee.Aggregate(ruleSet, out logInfo);

            Assert.IsFalse(result.Valid, "aggregated result has to be valid if all rules are valid.");
            Assert.AreEqual(1, result.Violations.Count, "violation was not passed to result.");
        }
        public void TestCreatingRulesetsWithRuleSubset()
        {
            var expectedErrors = new EdmLibTestErrors() 
            {
                {"(Foo1._!@#$%^&*())", EdmErrorCode.InvalidName},
                {"(Foo2._!@#$%^&*())", EdmErrorCode.InvalidName},
                {"(.)", EdmErrorCode.InvalidName},
                {"(.)",  EdmErrorCode.InvalidNamespaceName},
            };
            ValidationRuleSet ruleset = ValidationRuleSet.GetEdmModelRuleSet(Microsoft.OData.Edm.Library.EdmConstants.EdmVersion4);
            this.VerifySemanticValidation(ValidationTestModelBuilder.IEdmNamedElementNameIsNotAllowed(), ruleset, expectedErrors);

            ruleset = new ValidationRuleSet(ruleset.Except(new ValidationRule[] { ValidationRules.NamedElementNameIsNotAllowed }));
            expectedErrors = new EdmLibTestErrors() 
            {
                {null, null, EdmErrorCode.InvalidName},
                {null, null, EdmErrorCode.InvalidNamespaceName},
            };
            this.VerifySemanticValidation(ValidationTestModelBuilder.IEdmNamedElementNameIsNotAllowed(), ruleset, expectedErrors);
        }
Esempio n. 37
0
 public void SetUp()
 {
     this.mockery = new Mockery();
     this.testee = new ValidationRuleSet();
 }
Esempio n. 38
0
 private void ValidateUsingEdmValidator(IEdmModel model, ValidationRuleSet ruleSet, IEnumerable<EdmError> expectedErrors)
 {
     IEnumerable<EdmError> actualErrors;
     model.Validate(ruleSet, out actualErrors);
     this.CompareErrors(actualErrors, expectedErrors);
 }
        public void StopOnFirstViolation()
        {
            ValidationAggregator testee = new ValidationAggregator(this.validationFactory, true);

            IRuleSet<IValidationRule> ruleSet = new ValidationRuleSet
                                                    {
                                                        this.mockery.NewMock<IValidationRule>(),
                                                        this.mockery.NewMock<IValidationRule>()
                                                    };

            Expect.On(ruleSet[0]).Method("Evaluate").Will(Return.Value(new ValidationResult(false)));

            ValidationResult invalidResult = new ValidationResult(false);
            invalidResult.Violations.Add(new ValidationViolation("test"));
            Expect.On(ruleSet[1]).Method("Evaluate").Will(Return.Value(invalidResult));
            
            string logInfo;
            IValidationResult result = testee.Aggregate(ruleSet, out logInfo);

            Assert.IsFalse(result.Valid, "aggregated result has to be valid if all rules are valid.");
            Assert.AreEqual(0, result.Violations.Count, "the violation of the second rule should not be in the result because aggregation should have stopped on first invalid rule.");
        }
Esempio n. 40
0
        public void Evaluate()
        {
            IValidationRuleSetDescriptor ruleSetDescriptor = this.mockery.NewMock<IValidationRuleSetDescriptor>();

            Expect.On(ruleSetDescriptor).GetProperty("Factory").Will(Return.Value(this.validationFactory));

            IRuleSet<IValidationRule> ruleSet = new ValidationRuleSet { this.mockery.NewMock<IValidationRule>() };
            Expect.Once.On(this.defaultRulesProvider).Method("GetRules").With(ruleSetDescriptor).Will(Return.Value(ruleSet));
            Expect.Once.On(this.pluginRulesProvider).Method("GetRules").With(ruleSetDescriptor).Will(Return.Value(null));

            IValidationResult validationResult = this.mockery.NewMock<IValidationResult>();

            IValidationAggregator aggregator = this.mockery.NewMock<IValidationAggregator>();
            Stub.On(ruleSetDescriptor).GetProperty("Aggregator").Will(Return.Value(aggregator));
            Stub.On(aggregator).Method("Aggregate").With(ruleSet, Is.Out).Will(
                Return.Value(validationResult),
                Return.OutValue(1, "log"));

            IValidationResult result = this.testee.Evaluate(ruleSetDescriptor);
            Assert.AreEqual(validationResult, result, "result of aggregator is not passed correctly as result of Evaluate.");
        }
Esempio n. 41
0
		static SerializationValidator()
		{
			SerializationValidator.TypeReferenceTargetMustHaveValidName = new ValidationRule<IEdmTypeReference>((ValidationContext context, IEdmTypeReference typeReference) => {
				IEdmSchemaType definition = typeReference.Definition as IEdmSchemaType;
				if (definition != null && !EdmUtil.IsQualifiedName(definition.FullName()))
				{
					context.AddError(typeReference.Location(), EdmErrorCode.ReferencedTypeMustHaveValidName, Strings.Serializer_ReferencedTypeMustHaveValidName(definition.FullName()));
				}
			}
			);
			SerializationValidator.EntityReferenceTargetMustHaveValidName = new ValidationRule<IEdmEntityReferenceType>((ValidationContext context, IEdmEntityReferenceType entityReference) => {
				if (!EdmUtil.IsQualifiedName(entityReference.EntityType.FullName()))
				{
					context.AddError(entityReference.Location(), EdmErrorCode.ReferencedTypeMustHaveValidName, Strings.Serializer_ReferencedTypeMustHaveValidName(entityReference.EntityType.FullName()));
				}
			}
			);
			SerializationValidator.EntitySetTypeMustHaveValidName = new ValidationRule<IEdmEntitySet>((ValidationContext context, IEdmEntitySet set) => {
				if (!EdmUtil.IsQualifiedName(set.ElementType.FullName()))
				{
					context.AddError(set.Location(), EdmErrorCode.ReferencedTypeMustHaveValidName, Strings.Serializer_ReferencedTypeMustHaveValidName(set.ElementType.FullName()));
				}
			}
			);
			SerializationValidator.StructuredTypeBaseTypeMustHaveValidName = new ValidationRule<IEdmStructuredType>((ValidationContext context, IEdmStructuredType type) => {
				IEdmSchemaType baseType = type.BaseType as IEdmSchemaType;
				if (baseType != null && !EdmUtil.IsQualifiedName(baseType.FullName()))
				{
					context.AddError(type.Location(), EdmErrorCode.ReferencedTypeMustHaveValidName, Strings.Serializer_ReferencedTypeMustHaveValidName(baseType.FullName()));
				}
			}
			);
			SerializationValidator.NavigationPropertyVerifyAssociationName = new ValidationRule<IEdmNavigationProperty>((ValidationContext context, IEdmNavigationProperty property) => {
				if (!EdmUtil.IsQualifiedName(context.Model.GetAssociationFullName(property)))
				{
					context.AddError(property.Location(), EdmErrorCode.ReferencedTypeMustHaveValidName, Strings.Serializer_ReferencedTypeMustHaveValidName(context.Model.GetAssociationFullName(property)));
				}
			}
			);
			SerializationValidator.VocabularyAnnotationOutOfLineMustHaveValidTargetName = new ValidationRule<IEdmVocabularyAnnotation>((ValidationContext context, IEdmVocabularyAnnotation annotation) => {
				bool hasValue;
				EdmVocabularyAnnotationSerializationLocation? serializationLocation = annotation.GetSerializationLocation(context.Model);
				if (serializationLocation.GetValueOrDefault() != EdmVocabularyAnnotationSerializationLocation.OutOfLine)
				{
					hasValue = false;
				}
				else
				{
					hasValue = serializationLocation.HasValue;
				}
				if (hasValue && !EdmUtil.IsQualifiedName(annotation.TargetString()))
				{
					context.AddError(annotation.Location(), EdmErrorCode.InvalidName, Strings.Serializer_OutOfLineAnnotationTargetMustHaveValidName(EdmUtil.FullyQualifiedName(annotation.Target)));
				}
			}
			);
			SerializationValidator.VocabularyAnnotationMustHaveValidTermName = new ValidationRule<IEdmVocabularyAnnotation>((ValidationContext context, IEdmVocabularyAnnotation annotation) => {
				if (!EdmUtil.IsQualifiedName(annotation.Term.FullName()))
				{
					context.AddError(annotation.Location(), EdmErrorCode.InvalidName, Strings.Serializer_OutOfLineAnnotationTargetMustHaveValidName(annotation.Term.FullName()));
				}
			}
			);
			ValidationRule[] typeReferenceTargetMustHaveValidName = new ValidationRule[18];
			typeReferenceTargetMustHaveValidName[0] = SerializationValidator.TypeReferenceTargetMustHaveValidName;
			typeReferenceTargetMustHaveValidName[1] = SerializationValidator.EntityReferenceTargetMustHaveValidName;
			typeReferenceTargetMustHaveValidName[2] = SerializationValidator.EntitySetTypeMustHaveValidName;
			typeReferenceTargetMustHaveValidName[3] = SerializationValidator.StructuredTypeBaseTypeMustHaveValidName;
			typeReferenceTargetMustHaveValidName[4] = SerializationValidator.VocabularyAnnotationOutOfLineMustHaveValidTargetName;
			typeReferenceTargetMustHaveValidName[5] = SerializationValidator.VocabularyAnnotationMustHaveValidTermName;
			typeReferenceTargetMustHaveValidName[6] = SerializationValidator.NavigationPropertyVerifyAssociationName;
			typeReferenceTargetMustHaveValidName[7] = ValidationRules.FunctionImportEntitySetExpressionIsInvalid;
			typeReferenceTargetMustHaveValidName[8] = ValidationRules.FunctionImportParametersCannotHaveModeOfNone;
			typeReferenceTargetMustHaveValidName[9] = ValidationRules.FunctionOnlyInputParametersAllowedInFunctions;
			typeReferenceTargetMustHaveValidName[10] = ValidationRules.TypeMustNotHaveKindOfNone;
			typeReferenceTargetMustHaveValidName[11] = ValidationRules.PrimitiveTypeMustNotHaveKindOfNone;
			typeReferenceTargetMustHaveValidName[12] = ValidationRules.PropertyMustNotHaveKindOfNone;
			typeReferenceTargetMustHaveValidName[13] = ValidationRules.TermMustNotHaveKindOfNone;
			typeReferenceTargetMustHaveValidName[14] = ValidationRules.SchemaElementMustNotHaveKindOfNone;
			typeReferenceTargetMustHaveValidName[15] = ValidationRules.EntityContainerElementMustNotHaveKindOfNone;
			typeReferenceTargetMustHaveValidName[16] = ValidationRules.EnumMustHaveIntegerUnderlyingType;
			typeReferenceTargetMustHaveValidName[17] = ValidationRules.EnumMemberValueMustHaveSameTypeAsUnderlyingType;
			SerializationValidator.serializationRuleSet = new ValidationRuleSet(typeReferenceTargetMustHaveValidName);
		}