/// <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;
}
