/// <summary> /// Serialize the <see cref="EdmModel" /> to the XmlWriter. /// </summary> /// <param name="model"> /// The EdmModel to serialize, mut have only one <see cref="EdmNamespace" /> and one /// <see /// cref="Core.Metadata.Edm.EntityContainer" /> /// </param> /// <param name="xmlWriter"> The XmlWriter to serialize to </param> public bool Serialize(EdmModel model, XmlWriter xmlWriter) { Check.NotNull(model, "model"); Check.NotNull(xmlWriter, "xmlWriter"); if (model.Namespaces.Count != 1 || model.Containers.Count != 1) { Validator_OnError( this, new DataModelErrorEventArgs { ErrorMessage = Strings.Serializer_OneNamespaceAndOneContainer, }); } // validate the model first var validator = new DataModelValidator(); validator.OnError += Validator_OnError; validator.Validate(model, true); if (_isModelValid) { var visitor = new EdmSerializationVisitor(xmlWriter, model.Version); visitor.Visit(model); } return(_isModelValid); }
/// <summary> /// Serialize the <see cref="EdmModel" /> to the XmlWriter. /// </summary> /// <param name="model"> /// The EdmModel to serialize, mut have only one <see cref="EdmNamespace" /> and one /// <see /// cref="Core.Metadata.Edm.EntityContainer" /> /// </param> /// <param name="xmlWriter"> The XmlWriter to serialize to </param> public bool Serialize(EdmModel model, XmlWriter xmlWriter) { Check.NotNull(model, "model"); Check.NotNull(xmlWriter, "xmlWriter"); if (model.Namespaces.Count != 1 || model.Containers.Count != 1) { Validator_OnError( this, new DataModelErrorEventArgs { ErrorMessage = Strings.Serializer_OneNamespaceAndOneContainer, }); } // validate the model first var validator = new DataModelValidator(); validator.OnError += Validator_OnError; validator.Validate(model, true); if (_isModelValid) { var visitor = new EdmSerializationVisitor(xmlWriter, model.Version); visitor.Visit(model); } return _isModelValid; }
private readonly DataModelValidator validator; //validates input data public MenuViewModel() //main menu { validator = new DataModelValidator(); menuItems.Add(NewMenuItem("1. Modify entry", ModifyEntry)); menuItems.Add(NewMenuItem("2. Insert entry", InsertEnrty)); menuItems.Add(NewMenuItem("3. Delete entry", DeleteEntry)); menuItems.Add(NewMenuItem("4. Exit application", ExitProgram)); }
private DataModelValidatorResult GetValidationResult() { return(DataModelValidator.Validate(new IDataModelRuleProvider[] { generalSimulationSettingsDataRuleProvider, engineDataRuleProvider, aircraftDataRuleProvider })); }
public void Validate_DataModelsEmpty_ThrowsArgumentException() { // Call TestDelegate call = () => DataModelValidator.Validate(Enumerable.Empty <IDataModelRuleProvider>()); // Assert const string expectedMessage = "dataModels cannot be empty."; TestHelper.AssertThrowsArgumentException <ArgumentException>(call, expectedMessage); }
public void Validate_DataModelsNull_ThrowsArgumentNullException() { // Call TestDelegate call = () => DataModelValidator.Validate(null); // Assert Assert.That(call, Throws.ArgumentNullException .With.Property(nameof(ArgumentNullException.ParamName)) .EqualTo("dataModels")); }
public void Validate_WithTwoInvalidModels_ExecutesAllRulesAndReturnsInvalidResult() { // Setup var validationRuleOne = Substitute.For <IDataModelValidationRule>(); validationRuleOne.Execute().Returns(ValidationRuleResult.ValidResult); const string validationErrorOne = "Validation Error One"; var invalidValidationRuleOne = Substitute.For <IDataModelValidationRule>(); invalidValidationRuleOne.Execute().Returns(ValidationRuleResult.CreateInvalidResult(validationErrorOne)); var invalidProviderOne = Substitute.For <IDataModelRuleProvider>(); invalidProviderOne.GetDataModelValidationRules().Returns(new[] { validationRuleOne, invalidValidationRuleOne }); var validationRuleTwo = Substitute.For <IDataModelValidationRule>(); validationRuleTwo.Execute().Returns(ValidationRuleResult.ValidResult); const string validationErrorTwo = "Validation Error Two"; var invalidValidationRuleTwo = Substitute.For <IDataModelValidationRule>(); invalidValidationRuleTwo.Execute().Returns(ValidationRuleResult.CreateInvalidResult(validationErrorTwo)); var invalidProviderTwo = Substitute.For <IDataModelRuleProvider>(); invalidProviderTwo.GetDataModelValidationRules().Returns(new[] { validationRuleTwo, invalidValidationRuleTwo }); IDataModelRuleProvider[] models = { invalidProviderOne, invalidProviderTwo }; // Call DataModelValidatorResult result = DataModelValidator.Validate(models); // Assert Assert.That(result.IsValid, Is.False); CollectionAssert.AreEquivalent(new[] { validationErrorOne, validationErrorTwo }, result.ValidationMessages); }
internal virtual void Validate() { var validationErrors = new List<DataModelErrorEventArgs>(); var validator = new DataModelValidator(); validator.OnError += (_, e) => validationErrors.Add(e); validator.Validate(this, true); if (validationErrors.Count > 0) { throw new ModelValidationException(validationErrors); } }
public void Validate_WithOneValidAndOneInvalidDataModel_ExecutesAllRulesAndReturnsInvalidResult() { // Setup var validationRuleOne = Substitute.For <IDataModelValidationRule>(); validationRuleOne.Execute().Returns(ValidationRuleResult.ValidResult); var validProvider = Substitute.For <IDataModelRuleProvider>(); validProvider.GetDataModelValidationRules().Returns(new[] { validationRuleOne }); var validationRuleTwo = Substitute.For <IDataModelValidationRule>(); validationRuleTwo.Execute().Returns(ValidationRuleResult.ValidResult); const string validationError = "Validation Error"; var invalidValidationRule = Substitute.For <IDataModelValidationRule>(); invalidValidationRule.Execute().Returns(ValidationRuleResult.CreateInvalidResult(validationError)); var invalidProvider = Substitute.For <IDataModelRuleProvider>(); invalidProvider.GetDataModelValidationRules().Returns(new[] { validationRuleTwo, invalidValidationRule }); IDataModelRuleProvider[] models = { validProvider, invalidProvider }; // Call DataModelValidatorResult result = DataModelValidator.Validate(models); // Assert Assert.That(result.IsValid, Is.False); CollectionAssert.AreEqual(new[] { validationError }, result.ValidationMessages); }
public void When_store_function_name_has_a_dot() { var errors = new List<DataModelErrorEventArgs>(); var validator = new DataModelValidator(); validator.OnError += (s, a) => errors.Add(a); var model = new EdmModel(DataSpace.SSpace); model.AddItem(new EdmFunction("Has.Dots", "N", DataSpace.SSpace)); validator.Validate(model, validateSyntax: true); var error = errors.Single(); Assert.Equal("Name", error.PropertyName); Assert.Equal(Strings.EdmModel_Validator_Syntactic_EdmModel_NameIsNotAllowed("Has.Dots"), error.ErrorMessage); }
public void Validate_WithValidDataModels_ThenExecutesAllRulesAndReturnsValidResult() { // Setup var validationRuleOne = Substitute.For <IDataModelValidationRule>(); validationRuleOne.Execute().Returns(ValidationRuleResult.ValidResult); var validProviderOne = Substitute.For <IDataModelRuleProvider>(); validProviderOne.GetDataModelValidationRules().Returns(new[] { validationRuleOne }); var validationRuleTwo = Substitute.For <IDataModelValidationRule>(); validationRuleTwo.Execute().Returns(ValidationRuleResult.ValidResult); var validProviderTwo = Substitute.For <IDataModelRuleProvider>(); validProviderTwo.GetDataModelValidationRules().Returns(new[] { validationRuleTwo }); IDataModelRuleProvider[] models = { validProviderOne, validProviderTwo }; // Call DataModelValidatorResult result = DataModelValidator.Validate(models); // Assert Assert.That(result.IsValid, Is.True); Assert.That(result.ValidationMessages, Is.Empty); validProviderOne.Received(1).GetDataModelValidationRules(); validationRuleOne.Received(1).Execute(); validProviderTwo.Received(1).GetDataModelValidationRules(); validationRuleTwo.Received(1).Execute(); }
public bool Serialize(EdmModel model, XmlWriter xmlWriter, string modelNamespace = null) { Check.NotNull(model, "model"); Check.NotNull(xmlWriter, "xmlWriter"); bool modelIsValid = true; Action <DataModelErrorEventArgs> onErrorAction = e => { modelIsValid = false; if (OnError != null) { OnError(this, e); } }; if (model.NamespaceNames.Count() > 1 || model.Containers.Count() != 1) { onErrorAction( new DataModelErrorEventArgs { ErrorMessage = Strings.Serializer_OneNamespaceAndOneContainer, }); } // validate the model first var validator = new DataModelValidator(); validator.OnError += (_, e) => onErrorAction(e); validator.Validate(model, true); if (modelIsValid) { new EdmSerializationVisitor(xmlWriter, model.SchemaVersion).Visit(model, modelNamespace); return(true); } return(false); }
public bool Serialize(EdmModel model, XmlWriter xmlWriter, string modelNamespace = null) { Check.NotNull(model, "model"); Check.NotNull(xmlWriter, "xmlWriter"); bool modelIsValid = true; Action<DataModelErrorEventArgs> onErrorAction = e => { modelIsValid = false; if (OnError != null) { OnError(this, e); } }; if (model.NamespaceNames.Count() > 1 || model.Containers.Count() != 1) { onErrorAction( new DataModelErrorEventArgs { ErrorMessage = Strings.Serializer_OneNamespaceAndOneContainer, }); } // validate the model first var validator = new DataModelValidator(); validator.OnError += (_, e) => onErrorAction(e); validator.Validate(model, true); if (modelIsValid) { new EdmSerializationVisitor(xmlWriter, model.SchemaVersion).Visit(model, modelNamespace); return true; } return false; }
private bool ValidateModel(EdmModel model) { bool modelIsValid = true; Action <DataModelErrorEventArgs> onErrorAction = e => { // Ssdl serializer writes metadata items marked as invalid as comments // therefore we should not report errors for those. var metadataItem = e.Item as MetadataItem; if (metadataItem == null || !MetadataItemHelper.IsInvalid(metadataItem)) { modelIsValid = false; if (OnError != null) { OnError(this, e); } } }; if (model.NamespaceNames.Count() > 1 || model.Containers.Count() != 1) { onErrorAction( new DataModelErrorEventArgs { ErrorMessage = Strings.Serializer_OneNamespaceAndOneContainer, }); } var validator = new DataModelValidator(); validator.OnError += (_, e) => onErrorAction(e); validator.Validate(model, true); return(modelIsValid); }
private bool ValidateModel(EdmModel model) { bool modelIsValid = true; Action<DataModelErrorEventArgs> onErrorAction = e => { // Ssdl serializer writes metadata items marked as invalid as comments // therefore we should not report errors for those. var metadataItem = e.Item as MetadataItem; if (metadataItem == null || !MetadataItemHelper.IsInvalid(metadataItem)) { modelIsValid = false; if (OnError != null) { OnError(this, e); } } }; if (model.NamespaceNames.Count() > 1 || model.Containers.Count() != 1) { onErrorAction( new DataModelErrorEventArgs { ErrorMessage = Strings.Serializer_OneNamespaceAndOneContainer, }); } var validator = new DataModelValidator(); validator.OnError += (_, e) => onErrorAction(e); validator.Validate(model, true); return modelIsValid; }