public void AddCommand_does_not_add_command_if_not_possible()
{
var command = new ModificationCommand("T1", null, new ParameterNameGenerator(), p => p.TestProvider());
var batch = new ModificationCommandBatchFake();
batch.AddCommand(command);
batch.ShouldAddCommand = false;
batch.ShouldValidateSql = true;
batch.AddCommand(command);
Assert.Equal(1, batch.ModificationCommands.Count);
Assert.Equal(".", batch.CommandText);
}
public void AddCommand_does_not_add_command_if_resulting_sql_is_invalid()
{
var command = new ModificationCommand("T1", null, new ParameterNameGenerator(), p => p.TestProvider(), new TypedValueBufferFactoryFactory());
var batch = new ModificationCommandBatchFake();
batch.AddCommand(command);
batch.ShouldAddCommand = true;
batch.ShouldValidateSql = false;
batch.AddCommand(command);
Assert.Equal(1, batch.ModificationCommands.Count);
Assert.Equal(".", batch.CommandText);
}
public void AddCommand_adds_command_if_possible()
{
var command = new ModificationCommand("T1", null, new ParameterNameGenerator(), p => p.TestProvider(), new TypedValueBufferFactoryFactory());
var batch = new ModificationCommandBatchFake();
batch.AddCommand(command);
batch.ShouldAddCommand = true;
batch.ShouldValidateSql = true;
batch.AddCommand(command);
Assert.Equal(2, batch.ModificationCommands.Count);
Assert.Same(command, batch.ModificationCommands[0]);
Assert.Equal("..", batch.CommandText);
}
public void GenerateCommandText_compiles_deletes()
{
var stateEntry = CreateStateEntry(EntityState.Deleted);
var command = new ModificationCommand("T1", null, new ParameterNameGenerator());
command.AddStateEntry(stateEntry);
var sqlGeneratorMock = new Mock<SqlGenerator>();
var batch = new ModificationCommandBatchFake();
batch.AddCommand(command, sqlGeneratorMock.Object);
batch.GenerateCommandTextBase(sqlGeneratorMock.Object);
sqlGeneratorMock.Verify(g => g.AppendBatchHeader(It.IsAny<StringBuilder>()));
sqlGeneratorMock.Verify(g => g.AppendDeleteOperation(It.IsAny<StringBuilder>(), "T1", It.IsAny<IReadOnlyList<ColumnModification>>()));
}
public void UpdateCommandText_compiles_inserts()
{
var entry = CreateEntry(EntityState.Added);
var command = new ModificationCommand("T1", null, new ParameterNameGenerator(), p => p.TestProvider(), new TypedValueBufferFactoryFactory());
command.AddEntry(entry);
var sqlGeneratorMock = new Mock<IUpdateSqlGenerator>();
var batch = new ModificationCommandBatchFake(sqlGeneratorMock.Object);
batch.AddCommand(command);
batch.UpdateCachedCommandTextBase(0);
sqlGeneratorMock.Verify(g => g.AppendBatchHeader(It.IsAny<StringBuilder>()));
sqlGeneratorMock.Verify(g => g.AppendInsertOperation(It.IsAny<StringBuilder>(), command));
}
public async Task ExecuteAsync_saves_store_generated_values_when_updating()
{
var entry = CreateEntry(
EntityState.Modified, generateKeyValues: true, computeNonKeyValue: true);
var command = new ModificationCommand("T1", null, new ParameterNameGenerator().GenerateNext, true, null);
command.AddEntry(entry);
var connection = CreateConnection(
CreateFakeDataReader(new[] { "Col2" }, new List <object[]> {
new object[] { "FortyTwo" }
}));
var batch = new ModificationCommandBatchFake();
batch.AddCommand(command);
await batch.ExecuteAsync(connection);
Assert.Equal(1, entry[entry.EntityType.FindProperty("Id")]);
Assert.Equal("FortyTwo", entry[entry.EntityType.FindProperty("Name")]);
}
public async Task Exception_not_thrown_for_more_than_one_row_returned_for_single_command()
{
var entry = CreateEntry(EntityState.Added, generateKeyValues: true);
entry.MarkAsTemporary(entry.EntityType.GetPrimaryKey().Properties[0]);
var command = new ModificationCommand("T1", null, new ParameterNameGenerator(), p => p.Relational(), new BoxedValueReaderSource());
command.AddEntry(entry);
var mockReader = CreateDataReaderMock(new[] { "Col1" }, new List <object[]>
{
new object[] { 42 },
new object[] { 43 }
});
var batch = new ModificationCommandBatchFake(mockReader.Object);
batch.AddCommand(command);
await batch.ExecuteAsync(new Mock <RelationalTransaction>().Object, new RelationalTypeMapper(), new Mock <DbContext>().Object, new Mock <ILogger>().Object);
Assert.Equal(42, entry[entry.EntityType.GetProperty("Id")]);
}
public async Task Exception_thrown_if_rows_returned_for_command_without_store_generated_values_is_not_1()
{
var entry = CreateEntry(EntityState.Added);
var command = new ModificationCommand("T1", null, new ParameterNameGenerator().GenerateNext, true, null);
command.AddEntry(entry, true);
var connection = CreateConnection(
CreateFakeDataReader(
new[] { "Col1" }, new List <object[]> {
new object[] { 42 }
}));
var batch = new ModificationCommandBatchFake();
batch.AddCommand(command);
Assert.Equal(
RelationalStrings.UpdateConcurrencyException(1, 42),
(await Assert.ThrowsAsync <DbUpdateConcurrencyException>(
async() => await batch.ExecuteAsync(connection))).Message);
}
public void PopulateParameters_creates_parameter_for_condition_ModificationCommand()
{
var entry = CreateEntry(EntityState.Added, generateKeyValues: true);
var property = entry.EntityType.FindProperty("Id");
entry.SetTemporaryValue(property, 1);
var batch = new ModificationCommandBatchFake();
var parameterNameGenerator = new ParameterNameGenerator();
batch.TryAddCommand(
CreateModificationCommand(
"T1",
null,
true,
new[]
{
new ColumnModificationParameters(
entry,
property,
property.GetTableColumnMappings().Single().Column,
parameterNameGenerator.GenerateNext,
property.GetTableColumnMappings().Single().TypeMapping,
valueIsRead: false, valueIsWrite: false, columnIsKey: false, columnIsCondition: true,
sensitiveLoggingEnabled: true)
}));
batch.Complete();
var storeCommand = batch.StoreCommand;
Assert.Equal(1, storeCommand.RelationalCommand.Parameters.Count);
Assert.Equal("p0", storeCommand.RelationalCommand.Parameters[0].InvariantName);
Assert.Equal(1, storeCommand.ParameterValues.Count);
Assert.Equal(1, storeCommand.ParameterValues["p0"]);
}
public void PopulateParameters_creates_parameters_for_write_and_condition_ModificationCommand()
{
var entry = CreateEntry(EntityState.Added, generateKeyValues: true);
var property = entry.EntityType.FindProperty("Id");
entry.SetTemporaryValue(property, 1);
var batch = new ModificationCommandBatchFake();
var parameterNameGenerator = new ParameterNameGenerator();
batch.AddCommand(
new FakeModificationCommand(
"T1",
null,
parameterNameGenerator.GenerateNext,
true,
new List <ColumnModification>
{
new ColumnModification(
entry,
property,
property.GetTableColumnMappings().Single().Column,
parameterNameGenerator.GenerateNext,
isRead: false, isWrite: true, isKey: false, isCondition: true,
sensitiveLoggingEnabled: true)
}));
var storeCommand = batch.CreateStoreCommandBase();
Assert.Equal(2, storeCommand.RelationalCommand.Parameters.Count);
Assert.Equal("p0", storeCommand.RelationalCommand.Parameters[0].InvariantName);
Assert.Equal("p1", storeCommand.RelationalCommand.Parameters[1].InvariantName);
Assert.Equal(2, storeCommand.ParameterValues.Count);
Assert.Equal(1, storeCommand.ParameterValues["p0"]);
Assert.Equal(1, storeCommand.ParameterValues["p1"]);
}
public async Task ExecuteAsync_saves_store_generated_values()
{
var entry = CreateEntry(EntityState.Added, generateKeyValues: true);
entry.MarkAsTemporary(entry.EntityType.GetPrimaryKey().Properties[0]);
var command = new ModificationCommand("T1", null, new ParameterNameGenerator(), p => p.Relational(), new TypedValueBufferFactoryFactory());
command.AddEntry(entry);
var batch = new ModificationCommandBatchFake(CreateDataReaderMock(new[] { "Col1" }, new List <object[]> {
new object[] { 42 }
}).Object);
batch.AddCommand(command);
var transactionMock = new Mock <RelationalTransaction>(
Mock.Of <IRelationalConnection>(), Mock.Of <DbTransaction>(), false, Mock.Of <ILogger>());
await batch.ExecuteAsync(transactionMock.Object, new RelationalTypeMapper(), new Mock <DbContext>().Object, new Mock <ILogger>().Object);
Assert.Equal(42, entry[entry.EntityType.GetProperty("Id")]);
Assert.Equal("Test", entry[entry.EntityType.GetProperty("Name")]);
}
public async Task ExecuteAsync_saves_store_generated_values_on_non_key_columns()
{
var entry = CreateEntry(
EntityState.Added, generateKeyValues: true, computeNonKeyValue: true);
entry.MarkAsTemporary(entry.EntityType.GetPrimaryKey().Properties[0]);
var command = new ModificationCommand("T1", null, new ParameterNameGenerator(), p => p.TestProvider());
command.AddEntry(entry);
var batch = new ModificationCommandBatchFake(CreateDataReaderMock(new[] { "Col1", "Col2" }, new List <object[]> {
new object[] { 42, "FortyTwo" }
}).Object);
batch.AddCommand(command);
var connection = Mock.Of <IRelationalConnection>();
await batch.ExecuteAsync(connection, new Mock <ILogger>().Object);
Assert.Equal(42, entry[entry.EntityType.GetProperty("Id")]);
Assert.Equal("FortyTwo", entry[entry.EntityType.GetProperty("Name")]);
}
public async Task Exception_thrown_if_no_rows_returned_for_command_with_store_generated_values()
{
var entry = CreateEntry(EntityState.Added, generateKeyValues: true);
entry.MarkAsTemporary(entry.EntityType.GetPrimaryKey().Properties[0]);
var command = new ModificationCommand("T1", null, new ParameterNameGenerator(), p => p.Relational(), new TypedValueBufferFactoryFactory());
command.AddEntry(entry);
var batch = new ModificationCommandBatchFake(CreateDataReaderMock(new[] { "Col1" }, new List <object[]>()).Object);
batch.AddCommand(command);
var transaction = Mock.Of <IRelationalTransaction>();
Assert.Equal(Strings.UpdateConcurrencyException(1, 0),
(await Assert.ThrowsAsync <DbUpdateConcurrencyException>(
async() => await batch.ExecuteAsync(
transaction,
new ConcreteTypeMapper(),
new Mock <DbContext>().Object,
new Mock <ILogger>().Object))).Message);
}
public async Task Exception_thrown_if_rows_returned_for_command_without_store_generated_values_is_not_1()
{
var entry = CreateEntry(EntityState.Added);
var command = new ModificationCommand("T1", null, new ParameterNameGenerator(), p => p.TestProvider(), new TypedValueBufferFactoryFactory());
command.AddEntry(entry);
var batch = new ModificationCommandBatchFake(CreateDataReaderMock(new[] { "Col1" }, new List <object[]> {
new object[] { 42 }
}).Object);
batch.AddCommand(command);
var transaction = Mock.Of <IRelationalTransaction>();
Assert.Equal(Strings.UpdateConcurrencyException(1, 42),
(await Assert.ThrowsAsync <DbUpdateConcurrencyException>(
async() => await batch.ExecuteAsync(
transaction,
new ConcreteTypeMapper(),
new Mock <DbContext>().Object,
new Mock <ILogger>().Object))).Message);
}
public async Task Exception_thrown_if_no_rows_returned_for_command_with_store_generated_values(bool async)
{
var entry = CreateEntry(EntityState.Added, generateKeyValues: true);
entry.SetTemporaryValue(entry.EntityType.FindPrimaryKey().Properties[0], -1);
var command = CreateModificationCommand("T1", null, new ParameterNameGenerator().GenerateNext, true, null);
command.AddEntry(entry, true);
var connection = CreateConnection(
CreateFakeDataReader(new[] { "Col1" }, new List <object[]>()));
var batch = new ModificationCommandBatchFake();
batch.TryAddCommand(command);
batch.Complete();
var exception = async
? await Assert.ThrowsAsync <DbUpdateConcurrencyException>(() => batch.ExecuteAsync(connection))
: Assert.Throws <DbUpdateConcurrencyException>(() => batch.Execute(connection));
Assert.Equal(RelationalStrings.UpdateConcurrencyException(1, 0), exception.Message);
}
public async Task ExecuteAsync_saves_store_generated_values()
{
var entry = CreateEntry(EntityState.Added, generateKeyValues: true);
entry.MarkAsTemporary(entry.EntityType.FindPrimaryKey().Properties[0]);
var command = new ModificationCommand("T1", null, new ParameterNameGenerator().GenerateNext, true, null);
command.AddEntry(entry);
var connection = CreateConnection(
CreateFakeDataReader(new[] { "Col1" }, new List <object[]> {
new object[] { 42 }
}));
var batch = new ModificationCommandBatchFake();
batch.AddCommand(command);
await batch.ExecuteAsync(connection);
Assert.Equal(42, entry[entry.EntityType.FindProperty("Id")]);
Assert.Equal("Test", entry[entry.EntityType.FindProperty("Name")]);
}
public void PopulateParameters_does_not_create_parameter_for_read_ModificationCommand()
{
var entry = CreateEntry(EntityState.Added, generateKeyValues: true);
var property = entry.EntityType.FindProperty("Id");
entry.MarkAsTemporary(property);
var batch = new ModificationCommandBatchFake();
batch.AddCommand(
new FakeModificationCommand(
"T",
"S",
new ParameterNameGenerator(),
p => p.TestProvider(),
new List<ColumnModification>
{
new ColumnModification(
entry,
property,
property.TestProvider(),
new ParameterNameGenerator(),
true, false, false, false)
}));
var command = batch.CreateStoreCommandBase();
Assert.Equal(0, command.Parameters.Count);
}
public async Task Exception_thrown_if_no_rows_returned_for_command_with_store_generated_values()
{
var entry = CreateEntry(EntityState.Added, generateKeyValues: true);
entry.MarkAsTemporary(entry.EntityType.FindPrimaryKey().Properties[0]);
var command = new ModificationCommand("T1", null, new ParameterNameGenerator(), p => p.TestProvider());
command.AddEntry(entry);
var commandBuilderFactory = new FakeCommandBuilderFactory(
CreateFakeDataReader(new[] { "Col1" }, new List<object[]>()));
var batch = new ModificationCommandBatchFake(factory: commandBuilderFactory);
batch.AddCommand(command);
var connection = CreateConnection();
Assert.Equal(RelationalStrings.UpdateConcurrencyException(1, 0),
(await Assert.ThrowsAsync<DbUpdateConcurrencyException>(
async () => await batch.ExecuteAsync(connection))).Message);
}
public async Task Exception_thrown_if_rows_returned_for_command_without_store_generated_values_is_not_1()
{
var entry = CreateEntry(EntityState.Added);
var command = new ModificationCommand("T1", null, new ParameterNameGenerator(), p => p.TestProvider());
command.AddEntry(entry);
var commandBuilderFactory = new FakeCommandBuilderFactory(
CreateFakeDataReader(new[] { "Col1" }, new List<object[]> { new object[] { 42 } }));
var batch = new ModificationCommandBatchFake(factory: commandBuilderFactory);
batch.AddCommand(command);
var connection = CreateConnection();
Assert.Equal(RelationalStrings.UpdateConcurrencyException(1, 42),
(await Assert.ThrowsAsync<DbUpdateConcurrencyException>(
async () => await batch.ExecuteAsync(connection))).Message);
}
public async Task Exception_thrown_if_no_rows_returned_for_command_with_store_generated_values()
{
var stateEntry = CreateStateEntry(EntityState.Added, ValueGenerationOnSave.WhenInserting);
var command = new ModificationCommand("T1", null, new ParameterNameGenerator());
command.AddStateEntry(stateEntry);
var batch = new ModificationCommandBatchFake(CreateDataReaderMock(new[] { "Col1" }, new List<object[]>()).Object);
batch.AddCommand(command, new Mock<SqlGenerator> { CallBase = true }.Object);
Assert.Equal(Strings.FormatUpdateConcurrencyException(1, 0),
(await Assert.ThrowsAsync<DbUpdateConcurrencyException>(
async () => await batch.ExecuteAsync(new Mock<RelationalTransaction>().Object, new RelationalTypeMapper()))).Message);
}
public async Task ExecuteAsync_saves_store_generated_values()
{
var stateEntry = CreateStateEntry(EntityState.Added, ValueGenerationOnSave.WhenInserting);
var command = new ModificationCommand("T1", null, new ParameterNameGenerator());
command.AddStateEntry(stateEntry);
var batch = new ModificationCommandBatchFake(CreateDataReaderMock(new[] { "Col1" }, new List<object[]> { new object[] { 42 } }).Object);
batch.AddCommand(command, new Mock<SqlGenerator> { CallBase = true }.Object);
await batch.ExecuteAsync(new Mock<RelationalTransaction>().Object, new RelationalTypeMapper());
Assert.Equal(42, stateEntry[stateEntry.EntityType.GetProperty("Id")]);
Assert.Equal("Test", stateEntry[stateEntry.EntityType.GetProperty("Name")]);
}
public void UpdateCommandText_compiles_multiple_commands()
{
var entry = CreateEntry(EntityState.Added);
var command = new ModificationCommand("T1", null, new ParameterNameGenerator(), p => p.TestProvider(), new TypedValueBufferFactoryFactory());
command.AddEntry(entry);
var fakeSqlGenerator = new FakeSqlGenerator();
var batch = new ModificationCommandBatchFake(fakeSqlGenerator);
batch.AddCommand(command);
batch.AddCommand(command);
Assert.Equal("..", batch.CommandText);
Assert.Equal(1, fakeSqlGenerator.AppendBatchHeaderCalls);
}
public void CreateStoreCommand_creates_parameters_for_each_ModificationCommand_with_non_null_parameter_name()
{
var stateEntry = CreateStateEntry(EntityState.Added, ValueGenerationOnSave.WhenInserting);
var property = stateEntry.EntityType.GetProperty("Id");
var batch = new ModificationCommandBatchFake();
var commandMock = new Mock<ModificationCommand>();
commandMock.Setup(m => m.ColumnModifications).Returns(
new List<ColumnModification>
{
new ColumnModification(
stateEntry,
property,
parameterName: "p",
originalParameterName: null,
isRead: false,
isWrite: false,
isKey: false,
isCondition: false),
new ColumnModification(
stateEntry,
property,
parameterName: null,
originalParameterName: "op",
isRead: false,
isWrite: false,
isKey: false,
isCondition: false),
});
batch.AddCommand(commandMock.Object, new Mock<SqlGenerator> { CallBase = true }.Object);
var command = batch.CreateStoreCommandBase(CreateMockDbTransaction(), new RelationalTypeMapper());
Assert.Equal("p", command.Parameters[0].ParameterName);
Assert.Equal("op", command.Parameters[1].ParameterName);
}
public void UpdateCommandText_compiles_updates()
{
var entry = CreateEntry(EntityState.Modified, generateKeyValues: true);
var command = new ModificationCommand("T1", null, new ParameterNameGenerator().GenerateNext, p => p.TestProvider());
command.AddEntry(entry);
var sqlGeneratorMock = new Mock<IUpdateSqlGenerator>();
var batch = new ModificationCommandBatchFake(sqlGeneratorMock.Object);
batch.AddCommand(command);
batch.UpdateCachedCommandTextBase(0);
sqlGeneratorMock.Verify(g => g.AppendBatchHeader(It.IsAny<StringBuilder>()));
sqlGeneratorMock.Verify(g => g.AppendUpdateOperation(It.IsAny<StringBuilder>(), command, 0));
}
public void PopulateParameters_creates_parameter_for_write_and_condition_ModificationCommand()
{
var entry = CreateEntry(EntityState.Added, generateKeyValues: true);
var property = entry.EntityType.FindProperty("Id");
entry.MarkAsTemporary(property);
var batch = new ModificationCommandBatchFake();
batch.AddCommand(
new FakeModificationCommand(
"T",
"S",
new ParameterNameGenerator(),
p => p.TestProvider(),
new List<ColumnModification>
{
new ColumnModification(
entry,
property,
property.TestProvider(),
new ParameterNameGenerator().GenerateNext,
false, true, false, true)
}));
var storeCommand = batch.CreateStoreCommandBase();
Assert.Equal(2, storeCommand.RelationalCommand.Parameters.Count);
Assert.Equal("p0", storeCommand.RelationalCommand.Parameters[0].InvariantName);
Assert.Equal("p1", storeCommand.RelationalCommand.Parameters[1].InvariantName);
Assert.Equal(2, storeCommand.ParameterValues.Count);
Assert.Equal(1, storeCommand.ParameterValues["p0"]);
Assert.Equal(1, storeCommand.ParameterValues["p1"]);
}
public async Task ExecuteAsync_saves_store_generated_values_on_non_key_columns()
{
var entry = CreateEntry(
EntityState.Added, generateKeyValues: true, computeNonKeyValue: true);
entry.MarkAsTemporary(entry.EntityType.FindPrimaryKey().Properties[0]);
var command = new ModificationCommand("T1", null, new ParameterNameGenerator().GenerateNext, p => p.TestProvider());
command.AddEntry(entry);
var connection = CreateConnection(
CreateFakeDataReader(new[] { "Col1", "Col2" }, new List<object[]> { new object[] { 42, "FortyTwo" } }));
var batch = new ModificationCommandBatchFake();
batch.AddCommand(command);
await batch.ExecuteAsync(connection);
Assert.Equal(42, entry[entry.EntityType.FindProperty("Id")]);
Assert.Equal("FortyTwo", entry[entry.EntityType.FindProperty("Name")]);
}
public void PopulateParameters_does_not_create_parameter_for_read_ModificationCommand()
{
var entry = CreateEntry(EntityState.Added, generateKeyValues: true);
var property = entry.EntityType.GetProperty("Id");
entry.MarkAsTemporary(property);
var batch = new ModificationCommandBatchFake();
var commandBuilder = new CommandBuilderFake();
batch.PopulateParametersBase(
commandBuilder,
new ColumnModification(
entry,
property,
property.TestProvider(),
new ParameterNameGenerator(),
true, false, false, false));
Assert.Equal(0, commandBuilder.AddParameterCalls);
}
public async Task ExecuteAsync_saves_store_generated_values()
{
var entry = CreateEntry(EntityState.Added, generateKeyValues: true);
entry.MarkAsTemporary(entry.EntityType.GetPrimaryKey().Properties[0]);
var command = new ModificationCommand("T1", null, new ParameterNameGenerator(), p => p.TestProvider());
command.AddEntry(entry);
var batch = new ModificationCommandBatchFake(CreateDataReaderMock(new[] { "Col1" }, new List<object[]> { new object[] { 42 } }).Object);
batch.AddCommand(command);
var connection = Mock.Of<IRelationalConnection>();
await batch.ExecuteAsync(connection, new Mock<ILogger>().Object);
Assert.Equal(42, entry[entry.EntityType.GetProperty("Id")]);
Assert.Equal("Test", entry[entry.EntityType.GetProperty("Name")]);
}
public async Task ExecuteAsync_saves_store_generated_values_when_updating()
{
var entry = CreateEntry(
EntityState.Modified, generateKeyValues: true, computeNonKeyValue: true);
var command = new ModificationCommand("T1", null, new ParameterNameGenerator(), p => p.TestProvider(), new TypedValueBufferFactoryFactory());
command.AddEntry(entry);
var batch = new ModificationCommandBatchFake(CreateDataReaderMock(new[] { "Col2" }, new List<object[]> { new object[] { "FortyTwo" } }).Object);
batch.AddCommand(command);
var transaction = Mock.Of<IRelationalTransaction>();
await batch.ExecuteAsync(transaction, new ConcreteTypeMapper(), new Mock<DbContext>().Object, new Mock<ILogger>().Object);
Assert.Equal(1, entry[entry.EntityType.GetProperty("Id")]);
Assert.Equal("FortyTwo", entry[entry.EntityType.GetProperty("Name")]);
}
public async Task Exception_not_thrown_for_more_than_one_row_returned_for_single_command()
{
var entry = CreateEntry(EntityState.Added, generateKeyValues: true);
entry.MarkAsTemporary(entry.EntityType.GetPrimaryKey().Properties[0]);
var command = new ModificationCommand("T1", null, new ParameterNameGenerator(), p => p.TestProvider(), new TypedValueBufferFactoryFactory());
command.AddEntry(entry);
var mockReader = CreateDataReaderMock(new[] { "Col1" }, new List<object[]>
{
new object[] { 42 },
new object[] { 43 }
});
var batch = new ModificationCommandBatchFake(mockReader.Object);
batch.AddCommand(command);
var transaction = Mock.Of<IRelationalTransaction>();
await batch.ExecuteAsync(transaction, new ConcreteTypeMapper(), new Mock<DbContext>().Object, new Mock<ILogger>().Object);
Assert.Equal(42, entry[entry.EntityType.GetProperty("Id")]);
}
public async Task Exception_thrown_if_rows_returned_for_command_without_store_generated_values_is_not_1()
{
var entry = CreateEntry(EntityState.Added);
var command = new ModificationCommand("T1", null, new ParameterNameGenerator(), p => p.Relational(), new TypedValueBufferFactoryFactory());
command.AddEntry(entry);
var batch = new ModificationCommandBatchFake(CreateDataReaderMock(new[] { "Col1" }, new List<object[]> { new object[] { 42 } }).Object);
batch.AddCommand(command);
var transaction = Mock.Of<IRelationalTransaction>();
Assert.Equal(Strings.UpdateConcurrencyException(1, 42),
(await Assert.ThrowsAsync<DbUpdateConcurrencyException>(
async () => await batch.ExecuteAsync(
transaction,
new ConcreteTypeMapper(),
new Mock<DbContext>().Object,
new Mock<ILogger>().Object))).Message);
}
public async Task ExecuteAsync_executes_batch_commands_and_consumes_reader()
{
var entry = CreateEntry(EntityState.Added);
var command = new ModificationCommand("T1", null, new ParameterNameGenerator(), p => p.TestProvider(), new TypedValueBufferFactoryFactory());
command.AddEntry(entry);
var mockReader = CreateDataReaderMock();
var batch = new ModificationCommandBatchFake(mockReader.Object);
batch.AddCommand(command);
var transaction = Mock.Of<IRelationalTransaction>();
await batch.ExecuteAsync(transaction, new ConcreteTypeMapper(), new Mock<DbContext>().Object, new Mock<ILogger>().Object);
mockReader.Verify(r => r.ReadAsync(It.IsAny<CancellationToken>()), Times.Once);
mockReader.Verify(r => r.GetInt32(0), Times.Once);
}
public void CreateStoreCommand_creates_parameters_for_each_ModificationCommand()
{
var entry = CreateEntry(EntityState.Added, generateKeyValues: true);
var property = entry.EntityType.GetProperty("Id");
entry.MarkAsTemporary(property);
var batch = new ModificationCommandBatchFake();
var commandMock1 = new Mock<ModificationCommand>(
"T",
"S",
new ParameterNameGenerator(),
(Func<IProperty, IRelationalPropertyAnnotations>)(p => p.TestProvider()),
Mock.Of<IRelationalValueBufferFactoryFactory>());
commandMock1.Setup(m => m.ColumnModifications).Returns(
new List<ColumnModification>
{
new ColumnModification(
entry,
property,
property.TestProvider(),
new ParameterNameGenerator(),
false, true, false, false)
});
batch.AddCommand(commandMock1.Object);
var commandMock2 = new Mock<ModificationCommand>(
"T",
"S",
new ParameterNameGenerator(),
(Func<IProperty, IRelationalPropertyAnnotations>)(p => p.TestProvider()),
Mock.Of<IRelationalValueBufferFactoryFactory>());
commandMock2.Setup(m => m.ColumnModifications).Returns(
new List<ColumnModification>
{
new ColumnModification(
entry,
property,
property.TestProvider(),
new ParameterNameGenerator(),
false, true, false, false)
});
batch.AddCommand(commandMock2.Object);
var transaction = CreateMockDbTransaction();
var command = batch.CreateStoreCommandBase("foo", transaction, new ConcreteTypeMapper(), null);
Assert.Equal(CommandType.Text, command.CommandType);
Assert.Equal("foo", command.CommandText);
Assert.Same(transaction, command.Transaction);
Assert.Equal(2, batch.PopulateParameterCalls);
}
public async Task ExecuteAsync_saves_store_generated_values_on_non_key_columns()
{
var entry = CreateEntry(
EntityState.Added, generateKeyValues: true, computeNonKeyValue: true);
entry.MarkAsTemporary(entry.EntityType.GetPrimaryKey().Properties[0]);
var command = new ModificationCommand("T1", null, new ParameterNameGenerator(), p => p.Relational(), new TypedValueBufferFactoryFactory());
command.AddEntry(entry);
var batch = new ModificationCommandBatchFake(CreateDataReaderMock(new[] { "Col1", "Col2" }, new List<object[]> { new object[] { 42, "FortyTwo" } }).Object);
batch.AddCommand(command);
var transactionMock = new Mock<RelationalTransaction>(
Mock.Of<IRelationalConnection>(), Mock.Of<DbTransaction>(), false, Mock.Of<ILogger>());
await batch.ExecuteAsync(transactionMock.Object, new RelationalTypeMapper(), new Mock<DbContext>().Object, new Mock<ILogger>().Object);
Assert.Equal(42, entry[entry.EntityType.GetProperty("Id")]);
Assert.Equal("FortyTwo", entry[entry.EntityType.GetProperty("Name")]);
}
public async Task ExecuteAsync_executes_batch_commands_and_consumes_reader()
{
var stateEntry = CreateStateEntry(EntityState.Added);
var command = new ModificationCommand("T1", null, new ParameterNameGenerator());
command.AddStateEntry(stateEntry);
var mockReader = CreateDataReaderMock();
var batch = new ModificationCommandBatchFake(mockReader.Object);
batch.AddCommand(command, new Mock<SqlGenerator> { CallBase = true }.Object);
await batch.ExecuteAsync(new Mock<RelationalTransaction>().Object, new RelationalTypeMapper());
mockReader.Verify(r => r.ReadAsync(It.IsAny<CancellationToken>()), Times.Exactly(1));
mockReader.Verify(r => r.NextResultAsync(It.IsAny<CancellationToken>()), Times.Once);
}
public async Task Exception_thrown_if_no_rows_returned_for_command_with_store_generated_values()
{
var entry = CreateEntry(EntityState.Added, generateKeyValues: true);
entry.MarkAsTemporary(entry.EntityType.GetPrimaryKey().Properties[0]);
var command = new ModificationCommand("T1", null, new ParameterNameGenerator(), p => p.TestProvider(), new TypedValueBufferFactoryFactory());
command.AddEntry(entry);
var batch = new ModificationCommandBatchFake(CreateDataReaderMock(new[] { "Col1" }, new List<object[]>()).Object);
batch.AddCommand(command);
var transaction = Mock.Of<IRelationalTransaction>();
Assert.Equal(Strings.UpdateConcurrencyException(1, 0),
(await Assert.ThrowsAsync<DbUpdateConcurrencyException>(
async () => await batch.ExecuteAsync(
transaction,
new ConcreteTypeMapper(),
new Mock<DbContext>().Object,
new Mock<ILogger>().Object))).Message);
}
public async Task ExecuteAsync_executes_batch_commands_and_consumes_reader()
{
var entry = CreateEntry(EntityState.Added);
var command = new ModificationCommand("T1", null, new ParameterNameGenerator(), p => p.TestProvider());
command.AddEntry(entry);
var dbDataReader = CreateFakeDataReader();
var commandBuilderFactory = new FakeCommandBuilderFactory(dbDataReader);
var batch = new ModificationCommandBatchFake(factory: commandBuilderFactory);
batch.AddCommand(command);
var connection = CreateConnection();
await batch.ExecuteAsync(connection);
Assert.Equal(1, dbDataReader.ReadAsyncCount);
Assert.Equal(1, dbDataReader.GetInt32Count);
}
public void PopulateParameters_does_not_create_parameter_for_read_ModificationCommand()
{
var entry = CreateEntry(EntityState.Added, generateKeyValues: true);
var property = entry.EntityType.GetProperty("Id");
entry.MarkAsTemporary(property);
var batch = new ModificationCommandBatchFake();
var dbCommandMock = CreateDbCommandMock();
batch.PopulateParametersBase(dbCommandMock.Object,
new ColumnModification(
entry,
property,
property.TestProvider(),
new ParameterNameGenerator(),
true, false, false, false),
new ConcreteTypeMapper());
Assert.Equal(0, dbCommandMock.Object.Parameters.Count);
}
public async Task ExecuteAsync_saves_store_generated_values_when_updating()
{
var entry = CreateEntry(
EntityState.Modified, generateKeyValues: true, computeNonKeyValue: true);
var command = new ModificationCommand("T1", null, new ParameterNameGenerator(), p => p.TestProvider());
command.AddEntry(entry);
var commandBuilderFactory = new FakeCommandBuilderFactory(
CreateFakeDataReader(new[] { "Col2" }, new List<object[]> { new object[] { "FortyTwo" } }));
var batch = new ModificationCommandBatchFake(factory: commandBuilderFactory);
batch.AddCommand(command);
var connection = CreateConnection();
await batch.ExecuteAsync(connection);
Assert.Equal(1, entry[entry.EntityType.FindProperty("Id")]);
Assert.Equal("FortyTwo", entry[entry.EntityType.FindProperty("Name")]);
}
public async Task Exception_not_thrown_for_more_than_one_row_returned_for_single_command()
{
var entry = CreateEntry(EntityState.Added, generateKeyValues: true);
entry.MarkAsTemporary(entry.EntityType.FindPrimaryKey().Properties[0]);
var command = new ModificationCommand("T1", null, new ParameterNameGenerator(), p => p.TestProvider());
command.AddEntry(entry);
var commandBuilderFactory = new FakeCommandBuilderFactory(
CreateFakeDataReader(
new[] { "Col1" },
new List<object[]>
{
new object[] { 42 },
new object[] { 43 }
}));
var batch = new ModificationCommandBatchFake(factory: commandBuilderFactory);
batch.AddCommand(command);
var connection = CreateConnection();
await batch.ExecuteAsync(connection);
Assert.Equal(42, entry[entry.EntityType.FindProperty("Id")]);
}
public async Task Exception_not_thrown_for_more_than_one_row_returned_for_single_command()
{
var stateEntry = CreateStateEntry(EntityState.Added, ValueGenerationOnSave.WhenInserting);
var command = new ModificationCommand("T1", null, new ParameterNameGenerator());
command.AddStateEntry(stateEntry);
var mockReader = CreateDataReaderMock(new[] { "Col1" }, new List<object[]>
{
new object[] { 42 },
new object[] { 43 }
});
var batch = new ModificationCommandBatchFake(mockReader.Object);
batch.AddCommand(command, new Mock<SqlGenerator> { CallBase = true }.Object);
await batch.ExecuteAsync(new Mock<RelationalTransaction>().Object, new RelationalTypeMapper());
Assert.Equal(42, stateEntry[stateEntry.EntityType.GetProperty("Id")]);
}
