public void Sets_owned_type_keys()
{
var builder = new ModelBuilder(new ConventionSet());
var model = builder.Model;
((Model)model).SetProductVersion("2.1.0");
builder.Entity <Blog>(
b =>
{
b.Property(e => e.Id);
b.HasKey(e => e.Id);
b.OwnsOne(e => e.Details).WithOwner().HasForeignKey(e => e.BlogId);
});
var reporter = new TestOperationReporter();
new SnapshotModelProcessor(reporter).Process(model);
Assert.Empty(reporter.Messages);
Assert.Equal(
nameof(BlogDetails.BlogId),
model.FindEntityType(typeof(Blog)).FindNavigation(nameof(Blog.Details)).GetTargetType().FindPrimaryKey().Properties.Single()
.Name);
}
private MigrationsScaffolder CreateMigrationScaffolder <TContext>()
where TContext : DbContext, new()
{
var currentContext = new CurrentDbContext(new TContext());
var idGenerator = new MigrationsIdGenerator();
var code = new CSharpHelper();
var reporter = new TestOperationReporter();
return(new MigrationsScaffolder(
new MigrationsScaffolderDependencies(
currentContext,
new Model(),
new MigrationsAssembly(
currentContext,
new DbContextOptions <TContext>().WithExtension(new FakeRelationalOptionsExtension()),
idGenerator),
new MigrationsModelDiffer(
new TestRelationalTypeMapper(new RelationalTypeMapperDependencies()),
new MigrationsAnnotationProvider(new MigrationsAnnotationProviderDependencies()),
new FakeStateManager(),
RelationalTestHelpers.Instance.CreateCommandBatchPreparer()),
idGenerator,
new CSharpMigrationsGenerator(
new MigrationsCodeGeneratorDependencies(),
new CSharpMigrationsGeneratorDependencies(
code,
new CSharpMigrationOperationGenerator(
new CSharpMigrationOperationGeneratorDependencies(code)),
new CSharpSnapshotGenerator(new CSharpSnapshotGeneratorDependencies(code)))),
new MockHistoryRepository(),
reporter,
new MockProvider(),
new SnapshotModelProcessor(reporter))));
}
public void GenerateModel_warns_when_output_encoding()
{
using var projectDir = new TempDirectory();
var contextTemplate = Path.Combine(projectDir, "CodeTemplates", "EFCore", "DbContext.t4");
Directory.CreateDirectory(Path.GetDirectoryName(contextTemplate));
File.WriteAllText(
contextTemplate,
@"<#@ output encoding=""us-ascii"" #>");
var reporter = new TestOperationReporter();
var generator = CreateGenerator(reporter);
var model = new ModelBuilder()
.FinalizeModel();
var result = generator.GenerateModel(
model,
new()
{
ContextName = "Context",
ConnectionString = @"Name=DefaultConnection",
ProjectDir = projectDir
});
Assert.Collection(
reporter.Messages,
x =>
{
Assert.Equal(LogLevel.Warning, x.Level);
Assert.Equal(DesignStrings.EncodingIgnored("us-ascii"), x.Message);
});
}
private IMigrationsScaffolder CreateMigrationScaffolder <TContext>()
where TContext : DbContext, new()
{
var currentContext = new CurrentDbContext(new TContext());
var idGenerator = new MigrationsIdGenerator();
var code = new CSharpHelper();
var reporter = new TestOperationReporter();
var migrationAssembly
= new MigrationsAssembly(
currentContext,
new DbContextOptions <TContext>().WithExtension(new FakeRelationalOptionsExtension()),
idGenerator);
var historyRepository = new MockHistoryRepository();
var services = RelationalTestHelpers.Instance.CreateContextServices();
return(new MigrationsScaffolder(
new MigrationsScaffolderDependencies(
currentContext,
new Model(),
migrationAssembly,
new MigrationsModelDiffer(
new FallbackRelationalCoreTypeMapper(
TestServiceFactory.Instance.Create <CoreTypeMapperDependencies>(),
TestServiceFactory.Instance.Create <RelationalTypeMapperDependencies>(),
TestServiceFactory.Instance.Create <TestRelationalTypeMapper>()),
new MigrationsAnnotationProvider(new MigrationsAnnotationProviderDependencies()),
services.GetRequiredService <IChangeDetector>(),
services.GetRequiredService <StateManagerDependencies>(),
services.GetRequiredService <CommandBatchPreparerDependencies>()),
idGenerator,
new MigrationsCodeGeneratorSelector(
new[]
{
new CSharpMigrationsGenerator(
new MigrationsCodeGeneratorDependencies(),
new CSharpMigrationsGeneratorDependencies(
code,
new CSharpMigrationOperationGenerator(
new CSharpMigrationOperationGeneratorDependencies(code)),
new CSharpSnapshotGenerator(new CSharpSnapshotGeneratorDependencies(code))))
}),
historyRepository,
reporter,
new MockProvider(),
new SnapshotModelProcessor(reporter),
new Migrator(
migrationAssembly,
historyRepository,
services.GetRequiredService <IDatabaseCreator>(),
services.GetRequiredService <IMigrationsSqlGenerator>(),
services.GetRequiredService <IRawSqlCommandBuilder>(),
services.GetRequiredService <IMigrationCommandExecutor>(),
services.GetRequiredService <IRelationalConnection>(),
services.GetRequiredService <ISqlGenerationHelper>(),
services.GetRequiredService <IDiagnosticsLogger <DbLoggerCategory.Migrations> >(),
services.GetRequiredService <IDatabaseProvider>()))));
}
protected static IServiceCollection CreateServices()
{
var testAssembly = typeof(ModelCodeGeneratorTestBase).Assembly;
var reporter = new TestOperationReporter();
var services = new DesignTimeServicesBuilder(testAssembly, testAssembly, reporter, new string[0])
.CreateServiceCollection("Microsoft.EntityFrameworkCore.SqlServer");
return(services);
}
private static IModelCodeGenerator CreateGenerator()
{
var testAssembly = typeof(CSharpModelGeneratorTest).Assembly;
var reporter = new TestOperationReporter();
return(new DesignTimeServicesBuilder(testAssembly, testAssembly, reporter, new string[0])
.CreateServiceCollection("Microsoft.EntityFrameworkCore.SqlServer")
.AddSingleton <IAnnotationCodeGenerator, AnnotationCodeGenerator>()
.AddSingleton <IProviderConfigurationCodeGenerator, TestProviderCodeGenerator>()
.BuildServiceProvider()
.GetRequiredService <IModelCodeGenerator>());
}
public void Can_diff_against_older_ownership_model(Type snapshotType)
{
using var db = new Ownership.OwnershipContext();
var differ = db.GetService <IMigrationsModelDiffer>();
var snapshot = (ModelSnapshot)Activator.CreateInstance(snapshotType);
var reporter = new TestOperationReporter();
var processor = new SnapshotModelProcessor(reporter);
var differences = differ.GetDifferences(processor.Process(snapshot.Model), db.Model);
Assert.Empty(differences);
}
public void Create_works_when_BuildWebHost_throws()
{
var reporter = new TestOperationReporter();
var factory = new TestAppServiceProviderFactory(
MockAssembly.Create(typeof(ProgramWithThrowingBuildWebHost)),
reporter);
var services = factory.Create(Array.Empty <string>());
Assert.NotNull(services);
Assert.Contains(
"warn: " + DesignStrings.InvokeCreateHostBuilderFailed("This is a test."),
reporter.Messages);
}
public RelationalScaffoldingModelFactoryTest()
{
_reporter = new TestOperationReporter();
var assembly = typeof(RelationalScaffoldingModelFactoryTest).Assembly;
_factory = new DesignTimeServicesBuilder(assembly, assembly, _reporter, new string[0])
.CreateServiceCollection("Microsoft.EntityFrameworkCore.SqlServer")
.AddSingleton <IScaffoldingModelFactory, FakeScaffoldingModelFactory>()
.BuildServiceProvider(validateScopes: true)
.GetRequiredService <IScaffoldingModelFactory>();
_reporter.Clear();
}
public RelationalDatabaseModelFactoryTest()
{
_reporter = new TestOperationReporter();
var services = new ServiceCollection()
.AddEntityFrameworkDesignTimeServices(_reporter)
.AddSingleton <IScaffoldingModelFactory, FakeScaffoldingModelFactory>();
new SqlServerDesignTimeServices().ConfigureDesignTimeServices(services);
_factory = services
.BuildServiceProvider()
.GetRequiredService <IScaffoldingModelFactory>();
}
public SqliteDatabaseModelFactoryTest()
{
_testStore = SqliteTestStore.CreateScratch();
var reporter = new TestOperationReporter();
var serviceCollection = new ServiceCollection().AddScaffolding(reporter)
.AddSingleton <IOperationReporter>(reporter);
new SqliteDesignTimeServices().ConfigureDesignTimeServices(serviceCollection);
var serviceProvider = serviceCollection.BuildServiceProvider();
_factory = serviceProvider
.GetService <IDatabaseModelFactory>() as SqliteDatabaseModelFactory;
}
public void Invoke_warns_on_error()
{
var reporter = new TestOperationReporter();
var startup = new StartupInvoker(
reporter,
MockAssembly.Create(typeof(BadStartup)));
var services = startup.ConfigureServices();
Assert.NotNull(services);
Assert.Equal(
"warn: " + DesignStrings.InvokeStartupMethodFailed(
"ConfigureServices",
nameof(BadStartup),
"Something went wrong."),
reporter.Messages[0]);
}
public void Does_not_process_non_v1_models()
{
var model = new Model();
model.SetProductVersion("2.0.0");
model["Unicorn:DefaultSchema"] = "Value";
Assert.Equal(2, model.GetAnnotations().Count());
var reporter = new TestOperationReporter();
new SnapshotModelProcessor(reporter).Process(model);
Assert.Empty(reporter.Messages);
Assert.Equal(2, model.GetAnnotations().Count());
Assert.Equal("Value", (string)model["Unicorn:DefaultSchema"]);
}
public void Updates_provider_annotations_on_model()
{
var builder = new ModelBuilder(new ConventionSet());
var model = builder.Model;
((Model)model).SetProductVersion("1.1.2");
var entityType = builder.Entity <Blog>().Metadata;
var property = builder.Entity <Blog>().Property(e => e.Id).Metadata;
var key = builder.Entity <Blog>().HasKey(e => e.Id).Metadata;
builder.Entity <Post>().Property(e => e.BlogId);
var foreignKey = builder.Entity <Blog>().HasMany(e => e.Posts).WithOne(e => e.Blog).HasForeignKey(e => e.BlogId).Metadata;
var nav1 = foreignKey.DependentToPrincipal;
var nav2 = foreignKey.PrincipalToDependent;
var index = builder.Entity <Post>().HasIndex(e => e.BlogId).Metadata;
AddAnnotations(model);
AddAnnotations(entityType);
AddAnnotations(property);
AddAnnotations(key);
AddAnnotations(foreignKey);
AddAnnotations(nav1);
AddAnnotations(nav2);
AddAnnotations(index);
var reporter = new TestOperationReporter();
new SnapshotModelProcessor(reporter).Process(model);
AssertAnnotations(model);
AssertAnnotations(entityType);
AssertAnnotations(property);
AssertAnnotations(key);
AssertAnnotations(foreignKey);
AssertAnnotations(nav1);
AssertAnnotations(nav2);
AssertAnnotations(index);
Assert.Empty(reporter.Messages);
}
public void Does_not_warn_for_duplicate_non_conflicting_annotations()
{
var model = new ModelBuilder(new ConventionSet()).Model;
model.SetProductVersion("1.1.2");
model["Unicorn:DefaultSchema"] = "Value";
model["Hippo:DefaultSchema"] = "Value";
Assert.Equal(3, model.GetAnnotations().Count());
var reporter = new TestOperationReporter();
new SnapshotModelProcessor(reporter).Process(model);
Assert.Empty(reporter.Messages);
Assert.Equal(2, model.GetAnnotations().Count());
Assert.Equal("Value", (string)model["Relational:DefaultSchema"]);
}
public void Log_dampens_logLevel_when_ExecutedCommand()
{
var reporter = new TestOperationReporter();
var loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(new LoggerProvider(categoryName => new OperationLogger(categoryName, reporter)));
var logger = loggerFactory.CreateLogger <RelationalCommandBuilderFactory>();
logger.Log <object>(
LogLevel.Information,
(int)RelationalEventId.ExecutedCommand,
null,
null,
(_, __) => "-- Can't stop the SQL");
Assert.Collection(
reporter.Messages,
x => Assert.Equal("verbose: -- Can't stop the SQL", x));
}
private ServiceProvider CreateDesignServiceProvider(
string assemblyCode,
string startupAssemblyCode = null,
DbContext context = null)
{
var assembly = Compile(assemblyCode);
var startupAssembly = startupAssemblyCode == null
? assembly
: Compile(startupAssemblyCode);
var reporter = new TestOperationReporter();
var servicesBuilder = new DesignTimeServicesBuilder(assembly, startupAssembly, reporter, new string[0]);
return((context == null
? servicesBuilder
.CreateServiceCollection("Microsoft.EntityFrameworkCore.SqlServer")
: servicesBuilder
.CreateServiceCollection(context))
.BuildServiceProvider(validateScopes: true));
}
public void Log_dampens_logLevel_when_CommandExecuted()
{
var reporter = new TestOperationReporter();
var loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(new OperationLoggerProvider(reporter));
var logger = loggerFactory.CreateLogger(DbLoggerCategory.Database.Command.Name);
logger.Log <object>(
LogLevel.Information,
RelationalEventId.CommandExecuted,
null,
null,
(_, __) => "-- Can't stop the SQL");
Assert.Collection(
reporter.Messages,
x => Assert.Equal("verbose: -- Can't stop the SQL", x));
}
protected E2ETestBase(ITestOutputHelper output)
{
_output = output;
_reporter = new TestOperationReporter();
var serviceBuilder = new ServiceCollection()
.AddSingleton <IOperationReporter>(_reporter)
.AddScaffolding(_reporter)
.AddLogging();
ConfigureDesignTimeServices(serviceBuilder);
var serviceProvider = serviceBuilder
.AddSingleton(typeof(IFileService), sp => InMemoryFiles = new InMemoryFileService())
.BuildServiceProvider();
Generator = serviceProvider.GetRequiredService <IModelScaffolder>();
ScaffoldingModelFactory = serviceProvider.GetRequiredService <IScaffoldingModelFactory>();
}
public void Warns_for_conflicting_annotations_one_relational()
{
var model = new Model();
model.SetProductVersion("1.1.2");
model["Unicorn:DefaultSchema"] = "Value1";
model["Relational:DefaultSchema"] = "Value2";
Assert.Equal(3, model.GetAnnotations().Count());
var reporter = new TestOperationReporter();
new SnapshotModelProcessor(reporter).Process(model);
Assert.Equal("warn: " + DesignStrings.MultipleAnnotationConflict("DefaultSchema"), reporter.Messages.Single());
Assert.Equal(2, model.GetAnnotations().Count());
var actual = (string)model["Relational:DefaultSchema"];
Assert.True(actual == "Value1" || actual == "Value2");
}
public void GenerateModel_reports_errors()
{
using var projectDir = new TempDirectory();
var contextTemplate = Path.Combine(projectDir, "CodeTemplates", "EFCore", "DbContext.t4");
Directory.CreateDirectory(Path.GetDirectoryName(contextTemplate));
File.WriteAllText(
contextTemplate,
@"<# Warning(""This is a warning"");
Error(""This is an error""); #>");
var reporter = new TestOperationReporter();
var generator = CreateGenerator(reporter);
var model = new ModelBuilder()
.FinalizeModel();
var result = generator.GenerateModel(
model,
new()
{
ContextName = "Context",
ConnectionString = @"Name=DefaultConnection",
ProjectDir = projectDir
});
Assert.Collection(
reporter.Messages,
x =>
{
Assert.Equal(LogLevel.Warning, x.Level);
Assert.Contains("This is a warning", x.Message);
},
x =>
{
Assert.Equal(LogLevel.Error, x.Level);
Assert.Contains("This is an error", x.Message);
});
}
public RelationalDatabaseModelFactoryTest()
{
_reporter = new TestOperationReporter();
_factory = new FakeScaffoldingModelFactory(_reporter);
}
private IMigrationsScaffolder CreateMigrationScaffolder <TContext>()
where TContext : DbContext, new()
{
var currentContext = new CurrentDbContext(new TContext());
var idGenerator = new MigrationsIdGenerator();
var sqlServerTypeMappingSource = new SqlServerTypeMappingSource(
TestServiceFactory.Instance.Create <TypeMappingSourceDependencies>(),
TestServiceFactory.Instance.Create <RelationalTypeMappingSourceDependencies>());
var sqlServerAnnotationCodeGenerator = new SqlServerAnnotationCodeGenerator(
new AnnotationCodeGeneratorDependencies(sqlServerTypeMappingSource));
var code = new CSharpHelper(sqlServerTypeMappingSource);
var reporter = new TestOperationReporter();
var migrationAssembly
= new MigrationsAssembly(
currentContext,
new DbContextOptions <TContext>().WithExtension(new FakeRelationalOptionsExtension()),
idGenerator,
new FakeDiagnosticsLogger <DbLoggerCategory.Migrations>());
var historyRepository = new MockHistoryRepository();
var services = RelationalTestHelpers.Instance.CreateContextServices();
var model = new Model().FinalizeModel();
model.AddRuntimeAnnotation(RelationalAnnotationNames.RelationalModel, new RelationalModel(model));
return(new MigrationsScaffolder(
new MigrationsScaffolderDependencies(
currentContext,
model,
migrationAssembly,
new MigrationsModelDiffer(
new TestRelationalTypeMappingSource(
TestServiceFactory.Instance.Create <TypeMappingSourceDependencies>(),
TestServiceFactory.Instance.Create <RelationalTypeMappingSourceDependencies>()),
new MigrationsAnnotationProvider(
new MigrationsAnnotationProviderDependencies()),
services.GetRequiredService <IChangeDetector>(),
services.GetRequiredService <IUpdateAdapterFactory>(),
services.GetRequiredService <CommandBatchPreparerDependencies>()),
idGenerator,
new MigrationsCodeGeneratorSelector(
new[]
{
new CSharpMigrationsGenerator(
new MigrationsCodeGeneratorDependencies(
sqlServerTypeMappingSource,
sqlServerAnnotationCodeGenerator),
new CSharpMigrationsGeneratorDependencies(
code,
new CSharpMigrationOperationGenerator(
new CSharpMigrationOperationGeneratorDependencies(
code)),
new CSharpSnapshotGenerator(
new CSharpSnapshotGeneratorDependencies(
code, sqlServerTypeMappingSource, sqlServerAnnotationCodeGenerator))))
}),
historyRepository,
reporter,
new MockProvider(),
new SnapshotModelProcessor(reporter, services.GetRequiredService <IModelRuntimeInitializer>()),
new Migrator(
migrationAssembly,
historyRepository,
services.GetRequiredService <IDatabaseCreator>(),
services.GetRequiredService <IMigrationsSqlGenerator>(),
services.GetRequiredService <IRawSqlCommandBuilder>(),
services.GetRequiredService <IMigrationCommandExecutor>(),
services.GetRequiredService <IRelationalConnection>(),
services.GetRequiredService <ISqlGenerationHelper>(),
services.GetRequiredService <ICurrentDbContext>(),
services.GetRequiredService <IModelRuntimeInitializer>(),
services.GetRequiredService <IDiagnosticsLogger <DbLoggerCategory.Migrations> >(),
services.GetRequiredService <IRelationalCommandDiagnosticsLogger>(),
services.GetRequiredService <IDatabaseProvider>()))));
}
