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); }
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."); }
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", }); }
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); }
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", }); }
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(); }
/// <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); }
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)); }
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()); }
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); }
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\"" }); }
private void ValidateUsingEdmValidator(IEdmModel model, ValidationRuleSet ruleSet, IEnumerable <EdmError> expectedErrors) { IEnumerable <EdmError> actualErrors; model.Validate(ruleSet, out actualErrors); this.CompareErrors(actualErrors, expectedErrors); }
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); }
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); } }
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)); } }
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); }
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); }
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); }
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); }
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); }
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); }
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); }
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."); }
/// <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); }
public void SetUp() { this.mockery = new Mockery(); this.testee = new ValidationRuleSet(); }
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."); }
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."); }
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); }