public void SerializeAndDeserialize_Success()
{
JsonSerializerWrapper jsonSerializer = new JsonSerializerWrapper();
Dictionary <string, List <string> > HashToFilePathDict =
new Dictionary <string, List <string> >
{
{ "abc", new List <string> {
"123", "456"
} },
{ "def", new List <string> {
"789", "456"
} }
};
string tempFile = Guid.NewGuid().ToString();
try
{
jsonSerializer.Serialize(HashToFilePathDict, tempFile);
Dictionary <string, List <string> > testedHashToFilePathDict =
jsonSerializer.Deserialize <Dictionary <string, List <string> > >(tempFile);
Assert.Equal(HashToFilePathDict["abc"][0], testedHashToFilePathDict["abc"][0]);
Assert.Equal(HashToFilePathDict["abc"][1], testedHashToFilePathDict["abc"][1]);
Assert.Equal(HashToFilePathDict["def"][0], testedHashToFilePathDict["def"][0]);
}
finally
{
File.Delete(tempFile);
}
}
private async Task WriteSingleItem(SubscriptionScanDetails result, CancellationToken cancellation)
{
var resultFolder = Path.Combine(this.folderPath, result.Id);
if (!Directory.Exists(resultFolder))
{
Directory.CreateDirectory(resultFolder);
}
for (var i = 0; i < result.ResultFiles.Count; i++)
{
var destPath = Path.Combine(resultFolder, result.ResultFiles[i].FileName);
await using (Stream source = File.Open(result.ResultFiles[i].FullPath, FileMode.Open))
{
await using Stream destination = File.Create(destPath);
await source.CopyToAsync(destination, cancellation);
}
result.ResultFiles[i].FullPath = destPath;
}
var metadata = Path.Combine(resultFolder, $"meta.json");
var jsonResult = JsonSerializerWrapper.Serialize(result);
await File.WriteAllTextAsync(metadata, jsonResult, cancellation);
Logger.Information("{AzureSubscription} scanning result was written to {Folder}", result.Subscription, resultFolder);
}
public async Task Deserialize_DatabaseFromFile_AsExpected(string databaseName, int groupsCount)
{
string databasePath = Path.Combine(TestFilesDirectory, databaseName);
JsonSerializerWrapper jsonSerializerWrapper = new JsonSerializerWrapper();
List <TasksGroup> entities =
await jsonSerializerWrapper.Deserialize <List <TasksGroup> >(databasePath)
.ConfigureAwait(false);
Assert.Equal(groupsCount, entities.Count);
}
private async Task WriteSingleItem(ImageScanDetails result, CancellationToken cancellation)
{
// write JSON directly to a file
var img = result
.Image
.FullName
.Replace('/', '_')
.Replace(':', '_');
var resultPath = Path.Combine(this.folderPath, $"{img}.json");
var jsonResult = JsonSerializerWrapper.Serialize(result);
await File.WriteAllTextAsync(resultPath, jsonResult, cancellation);
Logger.Information("{Image} scanning result was written to {FileName}", result.Image.FullName, resultPath);
}
public async Task Serialize_WithTaskMeasurement_AsExpected()
{
JsonSerializerWrapper jsonSerializerWrapper = new JsonSerializerWrapper();
TaskGroupFactory tasksGroupFactory = new TaskGroupFactory(
A.Fake <IIDProducer>(), NullLogger <TaskGroupFactory> .Instance);
OperationResult <ITasksGroup> tasksGroupA = tasksGroupFactory.CreateGroup("a group", mTasksGroupProducer);
string taskId = tasksGroupFactory.CreateTask(tasksGroupA.Value, "task 1", mWorkTaskProducer).Value.ID;
TaskTriangleBuilder taskTriangleBuilder = new TaskTriangleBuilder();
taskTriangleBuilder.SetTime("18/10/2020".ToDateTime(), TimeSpan.FromDays(3.5))
.AddContent("todo 1")
.AddContent("todo 2")
.AddResource("one developer");
tasksGroupA.Value.SetMeasurement(taskId, taskTriangleBuilder.Build());
tasksGroupA.Value.GetTask(taskId).Value.TaskMeasurement.Content.MarkContentDone("todo 2");
List <ITasksGroup> entities = new List <ITasksGroup>
{
tasksGroupA.Value,
};
string tempSerializedFile = Path.GetRandomFileName();
try
{
await jsonSerializerWrapper.Serialize(entities, tempSerializedFile).ConfigureAwait(false);
string text = await File.ReadAllTextAsync(tempSerializedFile).ConfigureAwait(false);
Assert.Contains("\"StartTime\": \"2020-10-18T00:00:00\"", text);
Assert.Contains("\"ExpectedDuration\": \"3.12:00:00\"", text);
Assert.Contains("\"todo 1\": false", text);
Assert.Contains("\"todo 2\": true", text);
Assert.Contains("\"one developer\"", text);
}
finally
{
File.Delete(tempSerializedFile);
}
}
public async Task Serialize_AsExpected()
{
JsonSerializerWrapper jsonSerializerWrapper = new JsonSerializerWrapper();
TaskGroupFactory tasksGroupFactory = new TaskGroupFactory(
A.Fake <IIDProducer>(), NullLogger <TaskGroupFactory> .Instance);
OperationResult <ITasksGroup> tasksGroupA = tasksGroupFactory.CreateGroup("a group", mTasksGroupProducer);
tasksGroupFactory.CreateTask(tasksGroupA.Value, "task 1", mWorkTaskProducer);
OperationResult <ITasksGroup> tasksGroupB = tasksGroupFactory.CreateGroup("b group", mTasksGroupProducer);
tasksGroupFactory.CreateTask(tasksGroupB.Value, "task 3", mWorkTaskProducer);
List <ITasksGroup> entities = new List <ITasksGroup>
{
tasksGroupA.Value, tasksGroupB.Value
};
string tempSerializedFile = Path.GetRandomFileName();
try
{
await jsonSerializerWrapper.Serialize(entities, tempSerializedFile).ConfigureAwait(false);
string text = await File.ReadAllTextAsync(tempSerializedFile).ConfigureAwait(false);
Assert.Contains("\"GroupName\": \"a group\"", text);
Assert.Contains("\"Description\": \"task 1\"", text);
Assert.Contains("\"GroupName\": \"b group\"", text);
Assert.Contains("\"Description\": \"task 3\"", text);
}
finally
{
File.Delete(tempSerializedFile);
}
}
public ReferenceHandlerTests_IgnoreCycles_Metadata(JsonSerializerWrapper serializer)
: base(serializer)
{
}
public ReferenceHandlerTests_IgnoreCycles_Default(JsonSerializerWrapper serializer)
: base(serializer)
{
}
protected ConstructorTests_Metadata(JsonSerializerWrapper stringWrapper)
: base(stringWrapper)
{
}
public ConstructorTests_Default(JsonSerializerWrapper jsonSerializer) : base(jsonSerializer)
{
}
public JsonSerializerApiValidation(JsonSerializerWrapper serializer)
{
Serializer = serializer;
}
public IObjectTranslator <IEvent, StoredEvent> CreateEventTranslator()
{
return(new StoredEventTranslator(JsonSerializerWrapper.Create(false)));
}
public CollectionTests(JsonSerializerWrapper stringSerializerWrapper)
: base(stringSerializerWrapper)
{
}
public FirebaseConfig()
{
TimeoutInMinute = 1;
Serializer = new JsonSerializerWrapper();
}
protected SerializerTests(JsonSerializerWrapper serializerUnderTest)
{
Serializer = serializerUnderTest;
StreamingSerializer = serializerUnderTest as StreamingJsonSerializerWrapper;
}
