public void BatchCommands_creates_valid_batch_for_shared_table_added_entities()
{
var currentDbContext = CreateContextServices(CreateSharedTableModel()).GetRequiredService <ICurrentDbContext>();
var stateManager = currentDbContext.GetDependencies().StateManager;
var first = new FakeEntity {
Id = 42, Value = "Test"
};
var firstEntry = stateManager.GetOrCreateEntry(first);
firstEntry.SetEntityState(EntityState.Added);
var second = new RelatedFakeEntity {
Id = 42
};
var secondEntry = stateManager.GetOrCreateEntry(second);
secondEntry.SetEntityState(EntityState.Added);
var modelData = new UpdateAdapter(stateManager);
var commandBatches = CreateBatches(new[] { firstEntry, secondEntry }, modelData);
Assert.Single(commandBatches);
Assert.Equal(1, commandBatches.First().ModificationCommands.Count);
var command = commandBatches.First().ModificationCommands.Single();
Assert.Equal(EntityState.Added, command.EntityState);
Assert.Equal(4, command.ColumnModifications.Count);
var columnMod = command.ColumnModifications[0];
Assert.Equal(nameof(FakeEntity.Id), columnMod.ColumnName);
Assert.Equal(first.Id, columnMod.Value);
Assert.Equal(first.Id, columnMod.OriginalValue);
Assert.False(columnMod.IsCondition);
Assert.True(columnMod.IsKey);
Assert.False(columnMod.IsRead);
Assert.True(columnMod.IsWrite);
columnMod = command.ColumnModifications[1];
Assert.Equal(nameof(FakeEntity.RelatedId), columnMod.ColumnName);
Assert.Equal(first.RelatedId, columnMod.Value);
Assert.Equal(first.RelatedId, columnMod.OriginalValue);
Assert.False(columnMod.IsCondition);
Assert.False(columnMod.IsKey);
Assert.False(columnMod.IsRead);
Assert.True(columnMod.IsWrite);
columnMod = command.ColumnModifications[2];
Assert.Equal(nameof(FakeEntity.Value), columnMod.ColumnName);
Assert.Equal(first.Value, columnMod.Value);
Assert.Equal(first.Value, columnMod.OriginalValue);
Assert.False(columnMod.IsCondition);
Assert.False(columnMod.IsKey);
Assert.False(columnMod.IsRead);
Assert.True(columnMod.IsWrite);
}
public void BatchCommands_creates_valid_batch_for_shared_table_deleted_entities()
{
var currentDbContext = CreateContextServices(CreateSharedTableModel()).GetRequiredService <ICurrentDbContext>();
var stateManager = currentDbContext.GetDependencies().StateManager;
var first = new FakeEntity {
Id = 42, Value = "Test"
};
var firstEntry = stateManager.GetOrCreateEntry(first);
firstEntry.SetEntityState(EntityState.Deleted);
var second = new RelatedFakeEntity {
Id = 42
};
var secondEntry = stateManager.GetOrCreateEntry(second);
secondEntry.SetEntityState(EntityState.Deleted);
var commandBatches = RelationalTestHelpers.Instance.CreateCommandBatchPreparer(stateManager: stateManager)
.BatchCommands(new[] { firstEntry, secondEntry }).ToArray();
Assert.Equal(1, commandBatches.Length);
Assert.Equal(1, commandBatches.First().ModificationCommands.Count);
var command = commandBatches.First().ModificationCommands.Single();
Assert.Equal(EntityState.Deleted, command.EntityState);
Assert.Equal(2, command.ColumnModifications.Count);
var columnMod = command.ColumnModifications[0];
Assert.Equal(nameof(FakeEntity.Id), columnMod.ColumnName);
Assert.Equal(first.Id, columnMod.Value);
Assert.Equal(first.Id, columnMod.OriginalValue);
Assert.True(columnMod.IsCondition);
Assert.True(columnMod.IsKey);
Assert.False(columnMod.IsRead);
Assert.False(columnMod.IsWrite);
columnMod = command.ColumnModifications[1];
Assert.Equal(nameof(FakeEntity.RelatedId), columnMod.ColumnName);
Assert.Equal(first.RelatedId, columnMod.Value);
Assert.Equal(first.RelatedId, columnMod.OriginalValue);
Assert.True(columnMod.IsCondition);
Assert.False(columnMod.IsKey);
Assert.False(columnMod.IsRead);
Assert.False(columnMod.IsWrite);
}
public void BatchCommands_throws_on_conflicting_updates_for_shared_table_added_entities(bool sensitiveLogging)
{
var currentDbContext = CreateContextServices(CreateSharedTableModel()).GetRequiredService <ICurrentDbContext>();
var stateManager = currentDbContext.GetDependencies().StateManager;
var first = new FakeEntity
{
Id = 42,
Value = "Test"
};
var firstEntry = stateManager.GetOrCreateEntry(first);
firstEntry.SetEntityState(EntityState.Added);
var second = new RelatedFakeEntity
{
Id = 42
};
var secondEntry = stateManager.GetOrCreateEntry(second);
secondEntry.SetEntityState(EntityState.Deleted);
if (sensitiveLogging)
{
Assert.Equal(
RelationalStrings.ConflictingRowUpdateTypesSensitive(
nameof(RelatedFakeEntity), "{Id: 42}", EntityState.Deleted,
nameof(FakeEntity), "{Id: 42}", EntityState.Added),
Assert.Throws <InvalidOperationException>(
() => CreateCommandBatchPreparer(stateManager: stateManager, sensitiveLogging: true)
.BatchCommands(new[] { firstEntry, secondEntry }).ToArray()).Message);
}
else
{
Assert.Equal(
RelationalStrings.ConflictingRowUpdateTypes(
nameof(RelatedFakeEntity), EntityState.Deleted,
nameof(FakeEntity), EntityState.Added),
Assert.Throws <InvalidOperationException>(
() => CreateCommandBatchPreparer(stateManager: stateManager, sensitiveLogging: false)
.BatchCommands(new[] { firstEntry, secondEntry }).ToArray()).Message);
}
}
public void BatchCommands_throws_on_incomplete_updates_for_shared_table_no_principal(EntityState state, bool sensitiveLogging)
{
var currentDbContext = CreateContextServices(CreateSharedTableModel()).GetRequiredService <ICurrentDbContext>();
var stateManager = currentDbContext.GetDependencies().StateManager;
var first = new RelatedFakeEntity {
Id = 42
};
var firstEntry = stateManager.GetOrCreateEntry(first);
firstEntry.SetEntityState(state);
var second = new AnotherFakeEntity {
Id = 42
};
var secondEntry = stateManager.GetOrCreateEntry(second);
secondEntry.SetEntityState(state);
if (sensitiveLogging)
{
Assert.Equal(
RelationalStrings.SharedRowEntryCountMismatchSensitive(
nameof(RelatedFakeEntity), nameof(FakeEntity), nameof(FakeEntity), "Id:42", state),
Assert.Throws <InvalidOperationException>(
() => RelationalTestHelpers.Instance.CreateCommandBatchPreparer(stateManager: stateManager, sensitiveLogging: sensitiveLogging)
.BatchCommands(new[] { firstEntry }).ToArray()).Message);
}
else
{
Assert.Equal(
RelationalStrings.SharedRowEntryCountMismatch(
nameof(RelatedFakeEntity), nameof(FakeEntity), nameof(FakeEntity), state),
Assert.Throws <InvalidOperationException>(
() => RelationalTestHelpers.Instance.CreateCommandBatchPreparer(stateManager: stateManager, sensitiveLogging: sensitiveLogging)
.BatchCommands(new[] { firstEntry, secondEntry }).ToArray()).Message);
}
}
public void BatchCommands_throws_on_conflicting_values_for_shared_table_added_entities(bool useCurrentValues, bool sensitiveLogging)
{
var currentDbContext = CreateContextServices(CreateSharedTableModel()).GetRequiredService <ICurrentDbContext>();
var stateManager = currentDbContext.GetDependencies().StateManager;
var first = new FakeEntity {
Id = 42, Value = "Test"
};
var firstEntry = stateManager.GetOrCreateEntry(first);
firstEntry.SetEntityState(EntityState.Modified);
firstEntry.SetPropertyModified(firstEntry.EntityType.FindPrimaryKey().Properties.Single(), isModified: false);
var second = new RelatedFakeEntity {
Id = 42
};
var secondEntry = stateManager.GetOrCreateEntry(second);
secondEntry.SetEntityState(EntityState.Modified);
secondEntry.SetPropertyModified(secondEntry.EntityType.FindPrimaryKey().Properties.Single(), isModified: false);
if (useCurrentValues)
{
first.RelatedId = 1;
second.RelatedId = 2;
}
else
{
new EntityEntry <FakeEntity>(firstEntry).Property(e => e.RelatedId).OriginalValue = 1;
new EntityEntry <RelatedFakeEntity>(secondEntry).Property(e => e.RelatedId).OriginalValue = 2;
}
if (useCurrentValues)
{
if (sensitiveLogging)
{
Assert.Equal(
RelationalStrings.ConflictingRowValuesSensitive(
nameof(RelatedFakeEntity), nameof(FakeEntity), "{Id: 42}",
"{RelatedId: 2}", "{RelatedId: 1}", "{'RelatedId'}"),
Assert.Throws <InvalidOperationException>(
() => CreateCommandBatchPreparer(stateManager: stateManager, sensitiveLogging: true)
.BatchCommands(new[] { firstEntry, secondEntry }).ToArray()).Message);
}
else
{
Assert.Equal(
RelationalStrings.ConflictingRowValues(
nameof(RelatedFakeEntity), nameof(FakeEntity),
"{'RelatedId'}", "{'RelatedId'}", "{'RelatedId'}"),
Assert.Throws <InvalidOperationException>(
() => CreateCommandBatchPreparer(stateManager: stateManager, sensitiveLogging: false)
.BatchCommands(new[] { firstEntry, secondEntry }).ToArray()).Message);
}
}
else
{
if (sensitiveLogging)
{
Assert.Equal(
RelationalStrings.ConflictingOriginalRowValuesSensitive(
nameof(RelatedFakeEntity), nameof(FakeEntity), "{Id: 42}",
"{RelatedId: 2}", "{RelatedId: 1}", "{'RelatedId'}"),
Assert.Throws <InvalidOperationException>(
() => CreateCommandBatchPreparer(stateManager: stateManager, sensitiveLogging: true)
.BatchCommands(new[] { firstEntry, secondEntry }).ToArray()).Message);
}
else
{
Assert.Equal(
RelationalStrings.ConflictingOriginalRowValues(
nameof(RelatedFakeEntity), nameof(FakeEntity),
"{'RelatedId'}", "{'RelatedId'}", "{'RelatedId'}"),
Assert.Throws <InvalidOperationException>(
() => CreateCommandBatchPreparer(stateManager: stateManager, sensitiveLogging: false)
.BatchCommands(new[] { firstEntry, secondEntry }).ToArray()).Message);
}
}
}
