public void Can_add_type_mapped_parameter_by_property(bool nullable)
{
var typeMapper = new TestRelationalTypeMappingSource(
TestServiceFactory.Instance.Create <TypeMappingSourceDependencies>(),
TestServiceFactory.Instance.Create <RelationalTypeMappingSourceDependencies>());
var modelBuilder = RelationalTestHelpers.Instance.CreateConventionBuilder();
modelBuilder.Entity("MyType").Property <string>("MyProp").IsRequired(!nullable);
var model = modelBuilder.FinalizeModel(designTime: false, skipValidation: true);
var property = model.GetEntityTypes().Single().FindProperty("MyProp");
var parameterBuilder = new RelationalCommandBuilder(
new RelationalCommandBuilderDependencies(typeMapper));
parameterBuilder.AddParameter(
"InvariantName",
"Name",
property.GetRelationalTypeMapping(),
property.IsNullable);
Assert.Equal(1, parameterBuilder.Parameters.Count);
var parameter = parameterBuilder.Parameters[0] as TypeMappedRelationalParameter;
Assert.NotNull(parameter);
Assert.Equal("InvariantName", parameter.InvariantName);
Assert.Equal("Name", parameter.Name);
Assert.Equal(property.GetTypeMapping(), parameter.RelationalTypeMapping);
Assert.Equal(nullable, parameter.IsNullable);
}
public void Can_add_composite_parameter()
{
var typeMapper = new TestRelationalTypeMappingSource(
TestServiceFactory.Instance.Create <TypeMappingSourceDependencies>(),
TestServiceFactory.Instance.Create <RelationalTypeMappingSourceDependencies>());
var parameterBuilder = new RelationalCommandBuilder(
new RelationalCommandBuilderDependencies(
typeMapper));
parameterBuilder.AddCompositeParameter(
"CompositeInvariant",
new List <IRelationalParameter>
{
new TypeMappedRelationalParameter(
"FirstInvariant",
"FirstName",
new IntTypeMapping("int", DbType.Int32),
nullable: false),
new TypeMappedRelationalParameter(
"SecondInvariant",
"SecondName",
new StringTypeMapping("nvarchar(max)"),
nullable: true)
});
Assert.Equal(1, parameterBuilder.Parameters.Count);
var parameter = parameterBuilder.Parameters[0] as CompositeRelationalParameter;
Assert.NotNull(parameter);
Assert.Equal("CompositeInvariant", parameter.InvariantName);
Assert.Equal(2, parameter.RelationalParameters.Count);
}
public void Can_add_type_mapped_parameter_by_type(bool nullable)
{
var typeMapper = (IRelationalTypeMappingSource) new TestRelationalTypeMappingSource(
TestServiceFactory.Instance.Create <TypeMappingSourceDependencies>(),
TestServiceFactory.Instance.Create <RelationalTypeMappingSourceDependencies>());
var typeMapping = typeMapper.FindMapping(nullable ? typeof(int?) : typeof(int));
var parameterBuilder = new RelationalCommandBuilder(
new RelationalCommandBuilderDependencies(
typeMapper));
parameterBuilder.AddParameter(
"InvariantName",
"Name",
typeMapping,
nullable);
Assert.Equal(1, parameterBuilder.Parameters.Count);
var parameter = parameterBuilder.Parameters[0] as TypeMappedRelationalParameter;
Assert.NotNull(parameter);
Assert.Equal("InvariantName", parameter.InvariantName);
Assert.Equal("Name", parameter.Name);
Assert.Equal(typeMapping, parameter.RelationalTypeMapping);
Assert.Equal(nullable, parameter.IsNullable);
}
public void Can_add_type_mapped_parameter_by_property(bool nullable)
{
var typeMapper = new TestRelationalTypeMappingSource(
TestServiceFactory.Instance.Create <TypeMappingSourceDependencies>(),
TestServiceFactory.Instance.Create <RelationalTypeMappingSourceDependencies>());
var model = (IMutableModel) new Model();
var property = model.AddEntityType("MyType").AddProperty("MyProp", typeof(string));
property.IsNullable = nullable;
RelationalTestHelpers.Instance.CreateContextServices().GetRequiredService <IModelRuntimeInitializer>()
.Initialize(model.FinalizeModel(), designTime: false, validationLogger: null);
var parameterBuilder = new RelationalCommandBuilder(
new RelationalCommandBuilderDependencies(typeMapper));
parameterBuilder.AddParameter(
"InvariantName",
"Name",
property.GetRelationalTypeMapping(),
property.IsNullable);
Assert.Equal(1, parameterBuilder.Parameters.Count);
var parameter = parameterBuilder.Parameters[0] as TypeMappedRelationalParameter;
Assert.NotNull(parameter);
Assert.Equal("InvariantName", parameter.InvariantName);
Assert.Equal("Name", parameter.Name);
Assert.Equal(property.GetTypeMapping(), parameter.RelationalTypeMapping);
Assert.Equal(nullable, parameter.IsNullable);
}
public void Can_add_type_mapped_parameter_by_property(bool nullable)
{
var typeMapper = new TestRelationalTypeMappingSource(
TestServiceFactory.Instance.Create <TypeMappingSourceDependencies>(),
TestServiceFactory.Instance.Create <RelationalTypeMappingSourceDependencies>());
var property = ((IMutableModel) new Model()).AddEntityType("MyType").AddProperty("MyProp", typeof(string));
property.IsNullable = nullable;
property.SetTypeMapping(GetMapping(typeMapper, property));
var parameterBuilder = new RelationalCommandBuilder(
new RelationalCommandBuilderDependencies(
typeMapper));
parameterBuilder.AddParameter(
"InvariantName",
"Name",
property.GetRelationalTypeMapping(),
property.IsNullable);
Assert.Equal(1, parameterBuilder.Parameters.Count);
var parameter = parameterBuilder.Parameters[0] as TypeMappedRelationalParameter;
Assert.NotNull(parameter);
Assert.Equal("InvariantName", parameter.InvariantName);
Assert.Equal("Name", parameter.Name);
Assert.Equal(GetMapping(typeMapper, property), parameter.RelationalTypeMapping);
Assert.Equal(nullable, parameter.IsNullable);
}
public void Can_add_type_mapped_parameter_by_property(bool nullable)
{
var typeMapper = new TestRelationalTypeMappingSource(
TestServiceFactory.Instance.Create <TypeMappingSourceDependencies>(),
TestServiceFactory.Instance.Create <RelationalTypeMappingSourceDependencies>());
var property = new Model().AddEntityType("MyType").AddProperty("MyProp", typeof(string));
property.IsNullable = nullable;
property[CoreAnnotationNames.TypeMapping] = GetMapping(typeMapper, property);
var parameterBuilder = new RelationalCommandBuilder(
new RelationalCommandBuilderDependencies(
typeMapper,
new FakeDiagnosticsLogger <DbLoggerCategory.Database.Command>()));
parameterBuilder.AddParameter(
"InvariantName",
"Name",
property);
Assert.Equal(1, parameterBuilder.Parameters.Count);
var parameter = parameterBuilder.Parameters[0] as TypeMappedRelationalParameter;
Assert.NotNull(parameter);
Assert.Equal("InvariantName", parameter.InvariantName);
Assert.Equal("Name", parameter.Name);
Assert.Equal(GetMapping(typeMapper, property), parameter.RelationalTypeMapping);
Assert.Equal(nullable, parameter.IsNullable);
}
public void Builds_simple_command()
{
var commandBuilder = new RelationalCommandBuilder(
new FakeDiagnosticsLogger <DbLoggerCategory.Database.Command>(),
TestServiceFactory.Instance.Create <FakeRelationalTypeMapper>());
var command = commandBuilder.Build();
Assert.Equal("", command.CommandText);
Assert.Equal(0, command.Parameters.Count);
}
private static RelationalCommandBuilder CreateCommandBuilder()
{
var dependencies = new RelationalCommandBuilderDependencies(
new TestRelationalTypeMappingSource(
TestServiceFactory.Instance.Create <TypeMappingSourceDependencies>(),
TestServiceFactory.Instance.Create <RelationalTypeMappingSourceDependencies>()));
var commandBuilder = new RelationalCommandBuilder(dependencies);
return(commandBuilder);
}
public void Builds_simple_command()
{
var commandBuilder = new RelationalCommandBuilder(
new FakeDiagnosticsLogger <DbLoggerCategory.Database.Command>(),
new FakeRelationalTypeMapper(new RelationalTypeMapperDependencies()));
var command = commandBuilder.Build();
Assert.Equal("", command.CommandText);
Assert.Equal(0, command.Parameters.Count);
}
public void Builds_simple_command()
{
var commandBuilder = new RelationalCommandBuilder(
new FakeSensitiveDataLogger <RelationalCommand>(),
new DiagnosticListener("Fake"),
new FakeRelationalTypeMapper(new RelationalTypeMapperDependencies()));
var command = commandBuilder.Build();
Assert.Equal("", command.CommandText);
Assert.Equal(0, command.Parameters.Count);
}
private static RelationalCommandBuilder CreateCommandBuilder()
{
var dependencies = new RelationalCommandBuilderDependencies(
new TestRelationalTypeMappingSource(
TestServiceFactory.Instance.Create <TypeMappingSourceDependencies>(),
TestServiceFactory.Instance.Create <RelationalTypeMappingSourceDependencies>()),
new FakeDiagnosticsLogger <DbLoggerCategory.Database.Command>());
var commandBuilder = new RelationalCommandBuilder(dependencies);
return(commandBuilder);
}
public void Builds_simple_command()
{
var commandBuilder = new RelationalCommandBuilder(
new FakeInterceptingLogger <LoggerCategory.Database.Sql>(),
new DiagnosticListener("Fake"),
new FakeRelationalTypeMapper(new RelationalTypeMapperDependencies()));
var command = commandBuilder.Build();
Assert.Equal("", command.CommandText);
Assert.Equal(0, command.Parameters.Count);
}
public void Does_not_add_empty_composite_parameter()
{
var typeMapper = new TestRelationalTypeMappingSource(
TestServiceFactory.Instance.Create <TypeMappingSourceDependencies>(),
TestServiceFactory.Instance.Create <RelationalTypeMappingSourceDependencies>());
var parameterBuilder = new RelationalCommandBuilder(
new RelationalCommandBuilderDependencies(
typeMapper));
parameterBuilder.AddCompositeParameter(
"CompositeInvariant",
new List <IRelationalParameter>());
Assert.Equal(0, parameterBuilder.Parameters.Count);
}
public void Build_command_with_parameter()
{
var commandBuilder = new RelationalCommandBuilder(
new FakeDiagnosticsLogger <DbLoggerCategory.Database.Command>(),
TestServiceFactory.Instance.Create <FakeRelationalTypeMapper>());
commandBuilder.ParameterBuilder.AddParameter(
"InvariantName",
"Name",
new StringTypeMapping("nvarchar(100)"),
nullable: true);
var command = commandBuilder.Build();
Assert.Equal("", command.CommandText);
Assert.Equal(1, command.Parameters.Count);
Assert.Equal("InvariantName", command.Parameters[0].InvariantName);
}
public void Build_command_with_parameter()
{
var commandBuilder = new RelationalCommandBuilder(
new FakeSensitiveDataLogger <RelationalCommand>(),
new DiagnosticListener("Fake"),
new FakeRelationalTypeMapper(new RelationalTypeMapperDependencies()));
commandBuilder.ParameterBuilder.AddParameter(
"InvariantName",
"Name",
new RelationalTypeMapping("nvarchar(100)", typeof(string)),
nullable: true);
var command = commandBuilder.Build();
Assert.Equal("", command.CommandText);
Assert.Equal(1, command.Parameters.Count);
Assert.Equal("InvariantName", command.Parameters[0].InvariantName);
}
public void Can_add_dynamic_parameter()
{
var typeMapper = new TestRelationalTypeMappingSource(
TestServiceFactory.Instance.Create <TypeMappingSourceDependencies>(),
TestServiceFactory.Instance.Create <RelationalTypeMappingSourceDependencies>());
var parameterBuilder = new RelationalCommandBuilder(
new RelationalCommandBuilderDependencies(
typeMapper));
parameterBuilder.AddParameter(
"InvariantName",
"Name");
Assert.Equal(1, parameterBuilder.Parameters.Count);
var parameter = parameterBuilder.Parameters[0] as DynamicRelationalParameter;
Assert.NotNull(parameter);
Assert.Equal("InvariantName", parameter.InvariantName);
Assert.Equal("Name", parameter.Name);
}
