public async Task UpdateWhichDoesNotExistTest(NextApiTransport transport)
{
var now = DateTimeOffset.Now;
var uploadQueue = new List <UploadQueueDto>();
const string newDemonym = "NewDemonym";
var update = new UploadQueueDto
{
Id = Guid.NewGuid(),
OperationType = OperationType.Update,
OccuredAt = now,
EntityName = nameof(TestCity),
EntityRowGuid = Guid.NewGuid(),
ColumnName = nameof(TestCity.Demonym),
NewValue = newDemonym
};
uploadQueue.Add(update);
var service = ResolveQueueService(transport);
var resultDict = await service.ProcessAsync(uploadQueue);
Assert.Equal(UploadQueueError.EntityDoesNotExist, resultDict[update.Id].Error);
using var scope = App.ServerServices.CreateScope();
var serviceProvider = scope.ServiceProvider;
var testCityRepo = serviceProvider.GetService <IRepo <TestCity, Guid> >();
var testCity = await testCityRepo.GetAsync(city => city.Id == update.EntityRowGuid);
Assert.Null(testCity);
}
public async Task UpdateOrDeleteWithDefaultGuidTest(NextApiTransport transport)
{
var uploadQueue = new List <UploadQueueDto>();
var emptyGuidUpdateOp = new UploadQueueDto
{
Id = Guid.NewGuid(),
OccuredAt = DateTimeOffset.Now,
OperationType = OperationType.Update,
EntityName = nameof(TestCity),
ColumnName = nameof(TestCity.Name),
NewValue = "sadkf",
EntityRowGuid = Guid.Empty
};
var emptyGuidDeleteOp = new UploadQueueDto
{
Id = Guid.NewGuid(),
OccuredAt = DateTimeOffset.Now,
OperationType = OperationType.Delete,
EntityName = nameof(TestCity),
EntityRowGuid = Guid.Empty
};
uploadQueue.Add(emptyGuidUpdateOp);
uploadQueue.Add(emptyGuidDeleteOp);
var service = ResolveQueueService(transport);
var resultDict = await service.ProcessAsync(uploadQueue);
Assert.Equal(UploadQueueError.EntityDoesNotExist, resultDict[emptyGuidUpdateOp.Id].Error);
Assert.Equal(UploadQueueError.EntityDoesNotExist, resultDict[emptyGuidDeleteOp.Id].Error);
}
public async Task CreateAndUpdateTest(NextApiTransport transport)
{
var uploadQueue = new List <UploadQueueDto>();
var newTestCity = new TestCity {
Name = "MyNewTestCity", Population = 123456, Demonym = "MyTestCityDemonym"
};
var createOp = new UploadQueueDto
{
Id = Guid.NewGuid(),
OccuredAt = DateTimeOffset.Now,
OperationType = OperationType.Create,
EntityName = nameof(TestCity),
NewValue = JsonConvert.SerializeObject(newTestCity),
EntityRowGuid = newTestCity.Id
};
await Task.Delay(2000);
const string updatedName = "UpdatedName";
var updateOp = new UploadQueueDto
{
Id = Guid.NewGuid(),
OccuredAt = DateTimeOffset.Now,
OperationType = OperationType.Update,
EntityName = nameof(TestCity),
ColumnName = nameof(TestCity.Name),
NewValue = updatedName,
EntityRowGuid = newTestCity.Id
};
uploadQueue.Add(createOp);
uploadQueue.Add(updateOp);
var service = ResolveQueueService(transport);
var resultDict = await service.ProcessAsync(uploadQueue);
foreach (var keyValuePair in resultDict)
{
Assert.Equal(UploadQueueError.NoError, keyValuePair.Value.Error);
}
using var scope = App.ServerServices.CreateScope();
var serviceProvider = scope.ServiceProvider;
var testCityRepo = serviceProvider.GetService <IRepo <TestCity, Guid> >();
var newTestCityFromServer = await testCityRepo.GetAsync(city => city.Id == newTestCity.Id);
Assert.NotNull(newTestCityFromServer);
Assert.Equal(updatedName, newTestCityFromServer.Name);
}
public async Task CreateTwiceInSameBatchTest(NextApiTransport transport)
{
var uploadQueue = new List <UploadQueueDto>();
var newTestCity = new TestCity {
Name = "MyNewTestCity", Population = 123456, Demonym = "MyTestCityDemonym"
};
var createOp1 = new UploadQueueDto
{
Id = Guid.NewGuid(),
OccuredAt = DateTimeOffset.Now,
OperationType = OperationType.Create,
EntityName = nameof(TestCity),
NewValue = JsonConvert.SerializeObject(newTestCity),
EntityRowGuid = newTestCity.Id
};
var createOp2 = new UploadQueueDto
{
Id = Guid.NewGuid(),
OccuredAt = DateTimeOffset.Now,
OperationType = OperationType.Create,
EntityName = nameof(TestCity),
NewValue = JsonConvert.SerializeObject(newTestCity),
EntityRowGuid = newTestCity.Id
};
uploadQueue.Add(createOp1);
uploadQueue.Add(createOp2);
var service = ResolveQueueService(transport);
var resultDict = await service.ProcessAsync(uploadQueue);
Assert.Equal(uploadQueue.Count, resultDict.Count);
Assert.Contains(resultDict, pair => pair.Value.Error == UploadQueueError.NoError);
Assert.Contains(resultDict, pair => pair.Value.Error == UploadQueueError.OnlyOneCreateOperationAllowed);
}
public async Task ChangesHandlerTest(NextApiTransport transport)
{
var uploadQueue = new List <UploadQueueDto>();
var newTestCity = new TestCity
{
Name = "MyNewTestCity",
Population = 123456,
Demonym = "MyTestCityDemonym",
Id = TestUploadQueueChangesHandler.RejectCreateGuid
};
var createOp = new UploadQueueDto
{
Id = Guid.NewGuid(),
OccuredAt = DateTimeOffset.Now,
OperationType = OperationType.Create,
EntityName = nameof(TestCity),
NewValue = JsonConvert.SerializeObject(newTestCity),
EntityRowGuid = TestUploadQueueChangesHandler.RejectCreateGuid
};
var updateOp = new UploadQueueDto
{
Id = Guid.NewGuid(),
OccuredAt = DateTimeOffset.Now,
OperationType = OperationType.Update,
EntityName = nameof(TestCity),
ColumnName = nameof(TestCity.Demonym),
NewValue = "SomeNewDemonym",
EntityRowGuid = TestUploadQueueChangesHandler.RejectCreateGuid
};
await Task.Delay(1000);
uploadQueue.Add(createOp);
uploadQueue.Add(updateOp);
var service = ResolveQueueService(transport);
{
var resultDict = await service.ProcessAsync(uploadQueue);
Assert.Equal(uploadQueue.Count, resultDict.Count);
var createOpResult = resultDict[createOp.Id];
var updateOpResult = resultDict[updateOp.Id];
Assert.Equal(UploadQueueError.Exception, createOpResult.Error);
Assert.Contains(TestUploadQueueChangesHandler.RejectCreateGuidMessage, createOpResult.Extra.ToString());
Assert.Equal(UploadQueueError.Exception, updateOpResult.Error);
Assert.Contains(TestUploadQueueChangesHandler.RejectCreateGuidMessage, updateOpResult.Extra.ToString());
}
{
newTestCity.Id = TestUploadQueueChangesHandler.RejectUpdateGuid;
createOp.NewValue = JsonConvert.SerializeObject(newTestCity);
createOp.EntityRowGuid = newTestCity.Id;
updateOp.EntityRowGuid = newTestCity.Id;
var resultDict = await service.ProcessAsync(uploadQueue);
Assert.Equal(uploadQueue.Count, resultDict.Count);
var createOpResult = resultDict[createOp.Id];
var updateOpResult = resultDict[updateOp.Id];
Assert.Equal(UploadQueueError.NoError, createOpResult.Error);
Assert.Null(createOpResult.Extra);
Assert.Equal(UploadQueueError.Exception, updateOpResult.Error);
Assert.Contains(TestUploadQueueChangesHandler.RejectUpdateGuidMessage, updateOpResult.Extra.ToString());
}
{
newTestCity.Id = TestUploadQueueChangesHandler.RejectDeleteGuid;
createOp.NewValue = JsonConvert.SerializeObject(newTestCity);
createOp.EntityRowGuid = newTestCity.Id;
uploadQueue.Clear();
uploadQueue.Add(createOp);
var resultDictCreate = await service.ProcessAsync(uploadQueue);
Assert.Equal(uploadQueue.Count, resultDictCreate.Count);
var createOpResult = resultDictCreate[createOp.Id];
Assert.Equal(UploadQueueError.NoError, createOpResult.Error);
var deleteOp = new UploadQueueDto
{
Id = Guid.NewGuid(),
OccuredAt = DateTimeOffset.Now,
OperationType = OperationType.Delete,
EntityName = nameof(TestCity),
EntityRowGuid = createOp.EntityRowGuid
};
uploadQueue.Clear();
uploadQueue.Add(deleteOp);
var resultDict = await service.ProcessAsync(uploadQueue);
Assert.Equal(uploadQueue.Count, resultDict.Count);
var deleteOpResult = resultDict[deleteOp.Id];
Assert.Equal(UploadQueueError.Exception, deleteOpResult.Error);
Assert.Contains(TestUploadQueueChangesHandler.RejectDeleteGuidMessage, deleteOpResult.Extra.ToString());
}
}
public async Task DeleteTest(NextApiTransport transport)
{
await App.GenerateCities();
List <TestCity> all;
using (var serviceScope = App.ServerServices.CreateScope())
{
var testCityRepo = serviceScope.ServiceProvider.GetService <IRepo <TestCity, Guid> >();
all = testCityRepo.GetAll().ToList();
}
Assert.NotEmpty(all);
var rand = new Random();
var count = all.Count;
var random1 = -1;
var random2 = -1;
var equal = true;
while (equal)
{
var rand1 = rand.Next(count);
var rand2 = rand.Next(count);
if (rand1 == rand2)
{
continue;
}
equal = false;
random1 = rand1;
random2 = rand2;
}
Assert.NotEqual(-1, random1);
Assert.NotEqual(-1, random2);
var testCity1 = all[random1];
var testCity2 = all[random2];
const string entityName = nameof(TestCity);
var now = DateTimeOffset.Now;
var uploadQueue = new List <UploadQueueDto>();
var delete1 = new UploadQueueDto
{
Id = Guid.NewGuid(),
OperationType = OperationType.Delete,
OccuredAt = now,
EntityName = entityName,
EntityRowGuid = testCity1.Id
};
var delete2 = new UploadQueueDto
{
Id = Guid.NewGuid(),
OperationType = OperationType.Delete,
OccuredAt = now,
EntityName = entityName,
EntityRowGuid = testCity2.Id,
};
uploadQueue.Add(delete1);
uploadQueue.Add(delete2);
var service = ResolveQueueService(transport);
var resultDict = await service.ProcessAsync(uploadQueue);
foreach (var keyValuePair in resultDict)
{
Assert.Equal(UploadQueueError.NoError, keyValuePair.Value.Error);
}
using var scope = App.ServerServices.CreateScope();
var serviceProvider = scope.ServiceProvider;
var cityRepo = serviceProvider.GetService <IRepo <TestCity, Guid> >();
var testCity1FromServer = await cityRepo.GetAsync(city => city.Id == testCity1.Id);
Assert.Null(testCity1FromServer);
var testCity2FromServer = await cityRepo.GetAsync(city => city.Id == testCity2.Id);
Assert.Null(testCity2FromServer);
}
public async Task CheckLastChangeTest(NextApiTransport transport)
{
await App.GenerateCities();
List <TestCity> some;
using (var serviceScope = App.ServerServices.CreateScope())
{
var testCityRepo = serviceScope.ServiceProvider.GetService <IRepo <TestCity, Guid> >();
some = testCityRepo.GetAll().Take(10).ToList();
}
Assert.NotEmpty(some);
var uploadQueue = new List <UploadQueueDto>();
const string entityName = nameof(TestCity);
const string newDemonym = "NewDemonym";
foreach (var testCity in some)
{
await Task.Delay(1000);
var u = new UploadQueueDto
{
Id = Guid.NewGuid(),
OperationType = OperationType.Update,
OccuredAt = DateTimeOffset.UtcNow,
EntityName = entityName,
EntityRowGuid = testCity.Id,
ColumnName = nameof(TestCity.Demonym),
NewValue = $"{newDemonym}{testCity.Id}"
};
uploadQueue.Add(u);
}
var service = ResolveQueueService(transport);
var resultDict = await service.ProcessAsync(uploadQueue);
foreach (var keyValuePair in resultDict)
{
Assert.Equal(UploadQueueError.NoError, keyValuePair.Value.Error);
}
using var scope = App.ServerServices.CreateScope();
var serviceProvider = scope.ServiceProvider;
var columnChangesLogger = serviceProvider.GetService <IColumnChangesLogger>();
foreach (var uploadQueueDto in uploadQueue)
{
var lastChange = await columnChangesLogger.GetLastChange(entityName, uploadQueueDto.ColumnName,
uploadQueueDto.EntityRowGuid);
// I don't have an idea, why Equal(dt1, dt2) gives the terrible result as:
// Assert.Equal() Failure
// Expected: 2020-01-17T13:11:20.0984364+00:00
// Actual: 2020-01-17T13:11:20.0984360+00:00
Assert.Equal(
new DateTime(uploadQueueDto.OccuredAt.Year, uploadQueueDto.OccuredAt.Month,
uploadQueueDto.OccuredAt.Day, uploadQueueDto.OccuredAt.Hour, uploadQueueDto.OccuredAt.Minute,
uploadQueueDto.OccuredAt.Second), new DateTime(lastChange.Value.Year, lastChange.Value.Month,
lastChange.Value.Day, lastChange.Value.Hour, lastChange.Value.Minute,
lastChange.Value.Second));
}
}
public async Task OutdatedUpdateTest(NextApiTransport transport)
{
await App.GenerateCities();
List <TestCity> all;
using (var serviceScope = App.ServerServices.CreateScope())
{
var testCityRepo = serviceScope.ServiceProvider.GetService <IRepo <TestCity, Guid> >();
all = testCityRepo.GetAll().ToList();
}
Assert.NotEmpty(all);
var now = DateTimeOffset.Now;
const string newDemonym = "NewDemonym";
const string entityName = nameof(TestCity);
var testCity = all.FirstOrDefault();
Assert.NotNull(testCity);
var update = new UploadQueueDto
{
Id = Guid.NewGuid(),
OperationType = OperationType.Update,
OccuredAt = now,
EntityName = entityName,
EntityRowGuid = testCity.Id,
ColumnName = nameof(TestCity.Demonym),
NewValue = newDemonym
};
var uploadQueue = new List <UploadQueueDto> {
update
};
var service = ResolveQueueService(transport);
var resultDict = await service.ProcessAsync(uploadQueue);
Assert.Equal(UploadQueueError.NoError, resultDict[update.Id].Error);
uploadQueue.Clear();
var outdatedNow = now.Subtract(TimeSpan.FromMinutes(1));
const string newDemonymOutdated = "NewDemonymOutdated";
var outdatedUpdate = new UploadQueueDto
{
Id = Guid.NewGuid(),
OperationType = OperationType.Update,
OccuredAt = outdatedNow,
EntityName = entityName,
EntityRowGuid = testCity.Id,
ColumnName = nameof(TestCity.Demonym),
NewValue = newDemonymOutdated
};
uploadQueue.Add(outdatedUpdate);
resultDict = await service.ProcessAsync(uploadQueue);
Assert.Equal(UploadQueueError.OutdatedChange, resultDict[outdatedUpdate.Id].Error);
}
public async Task CreateAndUpdateStressTest(bool createAndUpdateInSameBatch, NextApiTransport transport)
{
var createUploadQueue = new List <UploadQueueDto>();
var updateUploadQueue = new List <UploadQueueDto>();
var testCities = new List <TestCity>();
for (var i = 0; i < 500; i++)
{
var newTestCity = new TestCity
{
Name = "MyNewTestCity" + i, Population = i, Demonym = "MyTestCityDemonym" + i
};
testCities.Add(newTestCity);
var createOp = new UploadQueueDto
{
Id = Guid.NewGuid(),
OccuredAt = DateTimeOffset.Now,
OperationType = OperationType.Create,
EntityName = nameof(TestCity),
NewValue = JsonConvert.SerializeObject(newTestCity),
EntityRowGuid = newTestCity.Id
};
var updatedName = "UpdatedName" + i;
newTestCity.Name = updatedName;
var updateOp = new UploadQueueDto
{
Id = Guid.NewGuid(),
OccuredAt = DateTimeOffset.Now,
OperationType = OperationType.Update,
EntityName = nameof(TestCity),
ColumnName = nameof(TestCity.Name),
NewValue = updatedName,
EntityRowGuid = newTestCity.Id
};
var updatedPopulation = i + 1;
newTestCity.Population = updatedPopulation;
var updateOp2 = new UploadQueueDto
{
Id = Guid.NewGuid(),
OccuredAt = DateTimeOffset.Now,
OperationType = OperationType.Update,
EntityName = nameof(TestCity),
ColumnName = nameof(TestCity.Population),
NewValue = updatedPopulation,
EntityRowGuid = newTestCity.Id
};
if (createAndUpdateInSameBatch)
{
createUploadQueue.Add(createOp);
createUploadQueue.Add(updateOp);
createUploadQueue.Add(updateOp2);
}
else
{
createUploadQueue.Add(createOp);
updateUploadQueue.Add(updateOp);
updateUploadQueue.Add(updateOp2);
}
}
var service = ResolveQueueService(transport);
var sw = new Stopwatch();
sw.Start();
var resultDict1 = await service.ProcessAsync(createUploadQueue);
_output.WriteLine(
$"Uploading createUploadQueue took {sw.Elapsed}, {nameof(createAndUpdateInSameBatch)}: {createAndUpdateInSameBatch}");
foreach (var keyValuePair in resultDict1)
{
Assert.Equal(UploadQueueError.NoError, keyValuePair.Value.Error);
}
using (var scope = App.ServerServices.CreateScope())
{
var serviceProvider = scope.ServiceProvider;
var testCityRepo = serviceProvider.GetService <IRepo <TestCity, Guid> >();
foreach (var testCity in testCities)
{
var testCityFromServer = await testCityRepo.GetAsync(city => city.Id == testCity.Id);
Assert.NotNull(testCityFromServer);
if (!createAndUpdateInSameBatch)
{
continue;
}
Assert.Equal(testCity.Name, testCityFromServer.Name);
Assert.Equal(testCity.Population, testCityFromServer.Population);
}
}
if (createAndUpdateInSameBatch)
{
return;
}
sw.Restart();
var resultDict2 = await service.ProcessAsync(updateUploadQueue);
_output.WriteLine($"Uploading updateUploadQueue took {sw.Elapsed}");
foreach (var keyValuePair in resultDict2)
{
Assert.Equal(UploadQueueError.NoError, keyValuePair.Value.Error);
}
using (var scope = App.ServerServices.CreateScope())
{
var serviceProvider = scope.ServiceProvider;
var testCityRepo = serviceProvider.GetService <IRepo <TestCity, Guid> >();
foreach (var newTestCity in testCities)
{
var newTestCityFromServer =
await testCityRepo.GetAsync(city => city.Id == newTestCity.Id);
Assert.NotNull(newTestCityFromServer);
Assert.Equal(newTestCity.Name, newTestCityFromServer.Name);
Assert.Equal(newTestCity.Population, newTestCityFromServer.Population);
}
}
}
public async Task GuidPropTest(NextApiTransport transport)
{
var uploadQueue = new List <UploadQueueDto>();
var newTestCity = new TestCity
{
GuidProp = Guid.NewGuid(),
NullableGuidProp = Guid.NewGuid()
};
var createOp1 = new UploadQueueDto
{
Id = Guid.NewGuid(),
OccuredAt = DateTimeOffset.Now,
OperationType = OperationType.Create,
EntityName = nameof(TestCity),
NewValue = JsonConvert.SerializeObject(newTestCity),
EntityRowGuid = newTestCity.Id
};
uploadQueue.Add(createOp1);
var service = ResolveQueueService(transport);
await service.ProcessAsync(uploadQueue);
// set to new Guid values
uploadQueue.Clear();
var updateOp = new UploadQueueDto
{
Id = Guid.NewGuid(),
OccuredAt = DateTimeOffset.Now,
OperationType = OperationType.Update,
EntityName = nameof(TestCity),
ColumnName = nameof(TestCity.GuidProp),
NewValue = Guid.NewGuid(),
EntityRowGuid = newTestCity.Id
};
var updateOp1 = new UploadQueueDto
{
Id = Guid.NewGuid(),
OccuredAt = DateTimeOffset.Now,
OperationType = OperationType.Update,
EntityName = nameof(TestCity),
ColumnName = nameof(TestCity.NullableGuidProp),
NewValue = Guid.NewGuid(),
EntityRowGuid = newTestCity.Id
};
uploadQueue.Add(updateOp);
uploadQueue.Add(updateOp1);
var resultDict = await service.ProcessAsync(uploadQueue);
Assert.Equal(uploadQueue.Count, resultDict.Count);
Assert.Equal(UploadQueueError.NoError, resultDict[updateOp.Id].Error);
Assert.Equal(UploadQueueError.NoError, resultDict[updateOp1.Id].Error);
// set to null
uploadQueue.Clear();
var updateOp2 = new UploadQueueDto
{
Id = Guid.NewGuid(),
OccuredAt = DateTimeOffset.Now,
OperationType = OperationType.Update,
EntityName = nameof(TestCity),
ColumnName = nameof(TestCity.NullableGuidProp),
NewValue = null,
EntityRowGuid = newTestCity.Id
};
uploadQueue.Add(updateOp2);
resultDict = await service.ProcessAsync(uploadQueue);
Assert.Equal(uploadQueue.Count, resultDict.Count);
Assert.Equal(UploadQueueError.NoError, resultDict[updateOp2.Id].Error);
}
public async Task SilentCreateDeleteTest(NextApiTransport transport)
{
var uploadQueue = new List <UploadQueueDto>();
var newTestCity = new TestCity
{
Id = Guid.NewGuid(),
Name = "MyNewTestCity1",
Population = 123456,
Demonym = "MyTestCityDemonym"
};
var createOp = new UploadQueueDto
{
Id = Guid.NewGuid(),
OccuredAt = DateTimeOffset.Now,
OperationType = OperationType.Create,
EntityName = nameof(TestCity),
NewValue = JsonConvert.SerializeObject(newTestCity),
EntityRowGuid = newTestCity.Id
};
var updateOp = new UploadQueueDto
{
Id = Guid.NewGuid(),
OccuredAt = DateTimeOffset.Now,
OperationType = OperationType.Update,
EntityName = nameof(TestCity),
ColumnName = nameof(TestCity.Name),
NewValue = "sadkf",
EntityRowGuid = newTestCity.Id
};
var deleteOp = new UploadQueueDto
{
Id = Guid.NewGuid(),
OccuredAt = DateTimeOffset.Now,
OperationType = OperationType.Delete,
EntityName = nameof(TestCity),
EntityRowGuid = newTestCity.Id
};
uploadQueue.Add(createOp);
uploadQueue.Add(updateOp);
uploadQueue.Add(deleteOp);
var service = ResolveQueueService(transport);
var resultDict = await service.ProcessAsync(uploadQueue);
foreach (var result in resultDict)
{
Assert.Equal(UploadQueueError.NoError, result.Value.Error);
}
// Check for default guids as well
createOp.EntityRowGuid = Guid.Empty;
updateOp.EntityRowGuid = Guid.Empty;
deleteOp.EntityRowGuid = Guid.Empty;
resultDict = await service.ProcessAsync(uploadQueue);
foreach (var result in resultDict)
{
Assert.Equal(UploadQueueError.NoError, result.Value.Error);
}
}
public async Task CreateWithDefaultGuidTest(NextApiTransport transport)
{
var uploadQueue = new List <UploadQueueDto>();
var newTestCity1 = new TestCity
{
Id = Guid.Empty,
Name = "MyNewTestCity1",
Population = 123456,
Demonym = "MyTestCityDemonym"
};
var newTestCity2 = new TestCity
{
Id = Guid.Empty,
Name = "MyNewTestCity2",
Population = 123456,
Demonym = "MyTestCityDemonym"
};
var createOp1 = new UploadQueueDto
{
Id = Guid.NewGuid(),
OccuredAt = DateTimeOffset.Now,
OperationType = OperationType.Create,
EntityName = nameof(TestCity),
NewValue = JsonConvert.SerializeObject(newTestCity1),
EntityRowGuid = newTestCity1.Id
};
var createOp2 = new UploadQueueDto
{
Id = Guid.NewGuid(),
OccuredAt = DateTimeOffset.Now,
OperationType = OperationType.Create,
EntityName = nameof(TestCity),
NewValue = JsonConvert.SerializeObject(newTestCity2),
EntityRowGuid = newTestCity2.Id
};
var emptyGuidUpdateOp = new UploadQueueDto
{
Id = Guid.NewGuid(),
OccuredAt = DateTimeOffset.Now,
OperationType = OperationType.Update,
EntityName = nameof(TestCity),
ColumnName = nameof(TestCity.Name),
NewValue = "sadkf",
EntityRowGuid = Guid.Empty
};
uploadQueue.Add(createOp1);
uploadQueue.Add(createOp2);
uploadQueue.Add(emptyGuidUpdateOp);
var service = ResolveQueueService(transport);
var resultDict = await service.ProcessAsync(uploadQueue);
Assert.Equal(UploadQueueError.NoError, resultDict[createOp1.Id].Error);
Assert.Equal(UploadQueueError.NoError, resultDict[createOp2.Id].Error);
Assert.Equal(UploadQueueError.EntityDoesNotExist, resultDict[emptyGuidUpdateOp.Id].Error);
}
public async Task UploadNullValues(NextApiTransport transport)
{
var uploadQueue = new List <UploadQueueDto>();
var newTestCity = new TestCity
{
Name = "MyNewTestCity", Population = 123456, Demonym = "MyTestCityDemonym", SomeNullableInt = 100
};
var createOp = new UploadQueueDto
{
Id = Guid.NewGuid(),
OccuredAt = DateTimeOffset.Now,
OperationType = OperationType.Create,
EntityName = nameof(TestCity),
NewValue = JsonConvert.SerializeObject(newTestCity),
EntityRowGuid = newTestCity.Id
};
uploadQueue.Add(createOp);
var service = ResolveQueueService(transport);
var resultDictCreate = await service.ProcessAsync(uploadQueue);
foreach (var keyValuePair in resultDictCreate)
{
Assert.Equal(UploadQueueError.NoError, keyValuePair.Value.Error);
}
using (var scope = App.ServerServices.CreateScope())
{
var serviceProvider = scope.ServiceProvider;
var testCityRepo = serviceProvider.GetService <IRepo <TestCity, Guid> >();
var newTestCityFromServer = await testCityRepo.GetAsync(city => city.Id == newTestCity.Id);
Assert.NotNull(newTestCityFromServer);
Assert.Equal(100, newTestCityFromServer.SomeNullableInt);
}
var updateOp = new UploadQueueDto
{
Id = Guid.NewGuid(),
OccuredAt = DateTimeOffset.Now,
OperationType = OperationType.Update,
EntityName = nameof(TestCity),
ColumnName = nameof(TestCity.SomeNullableInt),
NewValue = null,
EntityRowGuid = newTestCity.Id
};
uploadQueue.Clear();
uploadQueue.Add(updateOp);
var resultDictUpdate = await service.ProcessAsync(uploadQueue);
foreach (var keyValuePair in resultDictUpdate)
{
Assert.Equal(UploadQueueError.NoError, keyValuePair.Value.Error);
}
using (var scope = App.ServerServices.CreateScope())
{
var serviceProvider = scope.ServiceProvider;
var testCityRepo = serviceProvider.GetService <IRepo <TestCity, Guid> >();
var newTestCityFromServer = await testCityRepo.GetAsync(city => city.Id == newTestCity.Id);
Assert.NotNull(newTestCityFromServer);
Assert.Null(newTestCityFromServer.SomeNullableInt);
}
}
