private async Task <IEnumerable <IValidationError> > RunValidation(string messageString)
{
var serializationService = new XmlSerializationService();
var validationContext = new ValidationContext
{
Input = serializationService.Deserialize <Message>(messageString)
};
var preValidationContext = new PreValidationContext()
{
Input = messageString
};
var container = BuildContainer();
using (var scope = container.BeginLifetimeScope(c =>
{
c.RegisterInstance(validationContext).As <IValidationContext>();
c.RegisterInstance(preValidationContext).As <IPreValidationContext>();
}))
{
var preValidationPopulationService = scope.Resolve <IPopulationService>();
await preValidationPopulationService.PopulateAsync(CancellationToken.None);
var ruleSetOrchestrationService = scope.Resolve <IRuleSetOrchestrationService <ILearner, IValidationError> >();
return(await ruleSetOrchestrationService.Execute(CancellationToken.None));
}
}
public IRoot Deserialize()
{
Stream stream = new FileStream(_xsrcInput, FileMode.Open);
ISerializationService serializationService = new XmlSerializationService();
IRoot rootEntities = serializationService.Deserialize <Root>(stream);
stream.Close();
return(rootEntities);
}
public void ReadXml(XmlReader reader)
{
var serializer = new XmlSerializationService();
Id = reader.GetAttribute("id");
var subtreeReader = reader.ReadSubtree();
subtreeReader.MoveToContent();
while (subtreeReader.Read())
{
if (subtreeReader.NodeType == XmlNodeType.Element)
{
if (subtreeReader.LocalName.Equals("Data"))
{
var content = subtreeReader.ReadInnerXml();
if (typeof(TData) == typeof(string))
{
Data = (TData)Convert.ChangeType(content, typeof(string));
}
else
{
Data = serializer.Deserialize <TData>(content);
}
}
if (subtreeReader.LocalName.Equals("Output"))
{
if (subtreeReader.Depth == 1)
{
var content = subtreeReader.ReadOuterXml();
Output = serializer.Deserialize <ResultOutput <TData> >(content);
}
}
}
}
reader.Skip();
}
public void ShouldDeserializeObject()
{
var serizalizationService = new XmlSerializationService();
var pack = fixture.Create <Pack>();
string xml = string.Format(XmlPackFormat, pack.Guid, pack.Id, pack.Type, pack.Url);
Pack generatedPack = serizalizationService.Deserialize <Pack>(xml);
Assert.AreEqual(pack.Id, generatedPack.Id);
Assert.AreEqual(pack.Guid, generatedPack.Guid);
Assert.AreEqual(pack.Type, generatedPack.Type);
Assert.AreEqual(pack.Url, generatedPack.Url);
}
public void spawning_CanDeserialize()
{
//Arrange
var pathToXml = @"../../TestData/spawning.xml";
var xmlSerializationService = new XmlSerializationService();
var generalFileService = new LocalFileService();
//Act
var xml = generalFileService.Get(pathToXml);
var spawning = xmlSerializationService.Deserialize <spawning>(xml.Value).Value;
//Assert
Assert.IsNotNull(spawning);
Assert.IsTrue(spawning.Items.Length > 0);
}
public void gamestages_CanDeserialize()
{
//Arrange
var pathToXml = @"../../TestData/gamestages.xml";
var xmlSerializationService = new XmlSerializationService();
var generalFileService = new LocalFileService();
//Act
var xml = generalFileService.Get(pathToXml);
var gameStages = xmlSerializationService.Deserialize <gamestages>(xml.Value).Value;
//Assert
Assert.IsNotNull(gameStages);
Assert.IsTrue(gameStages.Items.Length > 0);
}
public void entitygroups_CanDeserialize()
{
//Arrange
var pathToXml = @"../../TestData/entitygroups.xml";
var xmlSerializationService = new XmlSerializationService();
var generalFileService = new LocalFileService();
//Act
var xml = generalFileService.Get(pathToXml);
var entityGroups = xmlSerializationService.Deserialize <entitygroups>(xml.Value).Value;
//Assert
Assert.IsNotNull(entityGroups);
Assert.IsTrue(entityGroups.Items.Length > 0);
}
public void entityclasses_CanDeserialize()
{
//Arrange
var pathToXml = @"../../TestData/entityclasses.xml";
var xmlSerializationService = new XmlSerializationService();
var generalFileService = new LocalFileService();
//Act
var xml = generalFileService.Get(pathToXml);
var entityClasses = xmlSerializationService.Deserialize <entity_classes>(xml.Value).Value;
//Serialize(entityClasses, @"C:\Users\Nate\Desktop\entityclassestest.xml");
//Assert
Assert.IsNotNull(entityClasses);
Assert.IsTrue(entityClasses.Items.Length > 0);
}
public async Task ShouldDeserializeTypedObjectsFromXml(string value)
{
const string file = "xml-serialization";
var serializationService = new XmlSerializationService();
var write = File.OpenWrite(file);
var writeInstance = new Opml {
Head = new OpmlHead {
Title = value
}
};
await serializationService.Serialize(writeInstance, write);
var read = File.OpenRead(file);
var readInstance = await serializationService.Deserialize <Opml>(read);
readInstance.Head.Title.Should().Be(value);
}
private static IMessage GetMessageFromFile(string fileName)
{
System.Console.WriteLine("Loading file..");
using (var stream = new FileStream(@"Files\" + fileName, FileMode.Open))
{
try
{
IXmlSerializationService serializationService = new XmlSerializationService();
return(serializationService.Deserialize <Message>(stream));
}
catch (Exception ex)
{
System.Console.WriteLine("File Load Error: Problem loading file... {0}", ex);
throw;
}
}
}
public static async Task <ValCurs> LoadValCursAsync(DateTime dateTime = default(DateTime))
{
if (dateTime == default(DateTime))
{
dateTime = DateTimeZones.NowMoscow;
}
var url = $"{UrlTemplate}{dateTime.ToString(DateFormat)}";
using (var client = new HttpClient())
{
var response = await client.GetAsync(url);
response.EnsureSuccessStatusCode(); // throw an exception if possible
var data = await response.Content.ReadAsStreamAsync();
using (data)
{
return(await XmlSerializationService.Deserialize <ValCurs>(data));
}
}
}
private async Task <Tuple <Message, ALBGlobal, ValidationErrorDto[], IDataStoreContext> > ReadAndDeserialiseAsync(
string ilrFilename,
string albFilename,
string valErrorsDtoFilename,
List <string> validLearners,
Mock <IKeyValuePersistenceService> storage,
Mock <IKeyValuePersistenceService> persist,
Mock <ISerializationService> serialise,
Mock <IValidationErrorsService> validationErrorsService)
{
var xmlSerialiser = new XmlSerializationService();
var jsonSerialiser = new JsonSerializationService();
const string validLearnersKey = "ValidLearners";
const string validLearnersSerialised = "<Serialised String>";
const string keyAlbOutput = "ALB_Output";
const string keyValErrors = "ValErrors";
const string keyValErrorsLookup = "ValErrorsLookup";
string ilrContents, albContents, valErrorsContents;
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
using (StreamReader sr = new StreamReader(ilrFilename))
{
ilrContents = await sr.ReadToEndAsync();
}
output.WriteLine($"Read ILR file: {stopwatch.ElapsedMilliseconds}");
stopwatch.Restart();
using (StreamReader sr = new StreamReader(albFilename))
{
albContents = await sr.ReadToEndAsync();
}
output.WriteLine($"Read ALB file: {stopwatch.ElapsedMilliseconds}");
stopwatch.Restart();
using (StreamReader sr = new StreamReader(valErrorsDtoFilename))
{
valErrorsContents = await sr.ReadToEndAsync();
}
output.WriteLine($"Read Val Errors file: {stopwatch.ElapsedMilliseconds}");
stopwatch.Restart();
Message message = xmlSerialiser.Deserialize <Message>(ilrContents);
output.WriteLine($"Deserialise ILR: {stopwatch.ElapsedMilliseconds}");
stopwatch.Restart();
ALBGlobal fundingOutputs = jsonSerialiser.Deserialize <ALBGlobal>(albContents);
output.WriteLine($"Deserialise ALB: {stopwatch.ElapsedMilliseconds}");
stopwatch.Restart();
ValidationErrorDto[] validationErrorDtos = jsonSerialiser.Deserialize <ValidationErrorDto[]>(valErrorsContents);
output.WriteLine($"Deserialise Val: {stopwatch.ElapsedMilliseconds}");
stopwatch.Restart();
var dataStoreContextMock = new Mock <IDataStoreContext>();
dataStoreContextMock.SetupGet(c => c.Filename).Returns(Path.GetFileName(ilrFilename));
dataStoreContextMock.SetupGet(c => c.OriginalFilename).Returns(Path.GetFileName(ilrFilename));
dataStoreContextMock.SetupGet(c => c.ValidLearnRefNumbersKey).Returns(validLearnersKey);
dataStoreContextMock.SetupGet(c => c.FileSizeInBytes).Returns(new FileInfo(ilrFilename).Length);
dataStoreContextMock.SetupGet(c => c.Ukprn).Returns(message.HeaderEntity.SourceEntity.UKPRN);
dataStoreContextMock.SetupGet(c => c.ValidLearnRefNumbersCount).Returns(validLearners.Count);
dataStoreContextMock.SetupGet(c => c.InvalidLearnRefNumbersCount).Returns(message.Learner.Length - validLearners.Count);
dataStoreContextMock.SetupGet(c => c.ValidationTotalErrorCount).Returns(10);
dataStoreContextMock.SetupGet(c => c.ValidationTotalWarningCount).Returns(20);
dataStoreContextMock.SetupGet(c => c.FundingALBOutputKey).Returns(keyAlbOutput);
dataStoreContextMock.SetupGet(c => c.ValidationErrorsKey).Returns(keyValErrors);
dataStoreContextMock.SetupGet(c => c.ValidationErrorsLookupsKey).Returns(keyValErrorsLookup);
dataStoreContextMock.SetupGet(c => c.SubmissionDateTimeUtc).Returns(new DateTime(2018, 1, 1));
storage.Setup(x => x.GetAsync(Path.GetFileName(ilrFilename), It.IsAny <CancellationToken>())).ReturnsAsync(ilrContents);
// storage.Setup(x => x.GetAsync(Path.GetFileName(albFilename))).ReturnsAsync(albContents);
persist.Setup(x => x.GetAsync(validLearnersKey, It.IsAny <CancellationToken>())).ReturnsAsync(validLearnersSerialised);
persist.Setup(x => x.GetAsync(keyAlbOutput, It.IsAny <CancellationToken>())).ReturnsAsync(albContents);
serialise.Setup(x => x.Deserialize <List <string> >(validLearnersSerialised)).Returns(validLearners);
serialise.Setup(x => x.Deserialize <Message>(ilrContents)).Returns(message);
serialise.Setup(x => x.Deserialize <ALBGlobal>(albContents)).Returns(fundingOutputs);
validationErrorsService.Setup(x => x.GetValidationErrorsAsync(keyValErrors, keyValErrorsLookup))
.ReturnsAsync(validationErrorDtos);
output.WriteLine($"Moq: {stopwatch.ElapsedMilliseconds}");
return(new Tuple <Message, ALBGlobal, ValidationErrorDto[], IDataStoreContext>(message, fundingOutputs, validationErrorDtos, dataStoreContextMock.Object));
}
