protected TestModelBuilder(TestHelpers testHelpers, Action <ModelConfigurationBuilder>?configure)
{
var options = new LoggingOptions();
options.Initialize(new DbContextOptionsBuilder().EnableSensitiveDataLogging(false).Options);
ValidationLoggerFactory = new ListLoggerFactory(l => l == DbLoggerCategory.Model.Validation.Name);
ValidationLogger = new DiagnosticsLogger <DbLoggerCategory.Model.Validation>(
ValidationLoggerFactory,
options,
new DiagnosticListener("Fake"),
testHelpers.LoggingDefinitions,
new NullDbContextLogger());
ModelLoggerFactory = new ListLoggerFactory(l => l == DbLoggerCategory.Model.Name);
var modelLogger = new DiagnosticsLogger <DbLoggerCategory.Model>(
ModelLoggerFactory,
options,
new DiagnosticListener("Fake"),
testHelpers.LoggingDefinitions,
new NullDbContextLogger());
ModelBuilder = testHelpers.CreateConventionBuilder(
modelLogger,
ValidationLogger,
configure == null ? null : c => configure(c));
}
// ReSharper disable once ParameterOnlyUsedForPreconditionCheck.Local
private void FilterTest(Func <string, bool> filter, params string[] expected)
{
var loggerFactory = new ListLoggerFactory(filter);
var dbLogger = new DiagnosticsLogger <DbLoggerCategory.Database>(
loggerFactory, new LoggingOptions(), new DiagnosticListener("Fake"), new TestLoggingDefinitions(),
new NullDbContextLogger());
var sqlLogger = new DiagnosticsLogger <DbLoggerCategory.Database.Command>(
loggerFactory, new LoggingOptions(), new DiagnosticListener("Fake"), new TestLoggingDefinitions(),
new NullDbContextLogger());
var queryLogger = new DiagnosticsLogger <DbLoggerCategory.Query>(
loggerFactory, new LoggingOptions(), new DiagnosticListener("Fake"), new TestLoggingDefinitions(),
new NullDbContextLogger());
var randomLogger = loggerFactory.CreateLogger("Random");
dbLogger.Logger.LogInformation(1, "DB1");
sqlLogger.Logger.LogInformation(2, "SQL1");
queryLogger.Logger.LogInformation(3, "Query1");
randomLogger.LogInformation(4, "Random1");
dbLogger.Logger.LogInformation(1, "DB2");
sqlLogger.Logger.LogInformation(2, "SQL2");
queryLogger.Logger.LogInformation(3, "Query2");
randomLogger.LogInformation(4, "Random2");
Assert.Equal(expected, loggerFactory.Log.Select(l => l.Message));
}
protected TestModelBuilder(TestHelpers testHelpers)
{
Log = new List <(LogLevel, EventId, string)>();
var options = new LoggingOptions();
options.Initialize(new DbContextOptionsBuilder().EnableSensitiveDataLogging(false).Options);
var validationLogger = new DiagnosticsLogger <DbLoggerCategory.Model.Validation>(
new ListLoggerFactory(Log, l => l == DbLoggerCategory.Model.Validation.Name),
options,
new DiagnosticListener("Fake"));
var modelLogger = new DiagnosticsLogger <DbLoggerCategory.Model>(
new ListLoggerFactory(Log, l => l == DbLoggerCategory.Model.Name),
options,
new DiagnosticListener("Fake"));
var contextServices = testHelpers.CreateContextServices();
ModelBuilder = new ModelBuilder(
new CompositeConventionSetBuilder(contextServices.GetRequiredService <IEnumerable <IConventionSetBuilder> >().ToList())
.AddConventions(
new CoreConventionSetBuilder(
contextServices.GetRequiredService <CoreConventionSetBuilderDependencies>().With(modelLogger))
.CreateConventionSet()));
ModelValidator = new ModelValidator(new ModelValidatorDependencies(validationLogger, modelLogger));
}
/// <summary>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </summary>
protected virtual KeyBuilder VisitPrimaryKey([NotNull] EntityTypeBuilder builder, [NotNull] DatabaseTable table)
{
Check.NotNull(builder, nameof(builder));
Check.NotNull(table, nameof(table));
var primaryKey = table.PrimaryKey;
if (primaryKey == null)
{
_reporter.WriteWarning(DesignStrings.MissingPrimaryKey(table.DisplayName()));
return(null);
}
var unmappedColumns = primaryKey.Columns
.Where(c => _unmappedColumns.Contains(c))
.Select(c => c.Name)
.ToList();
if (unmappedColumns.Count > 0)
{
_reporter.WriteWarning(
DesignStrings.PrimaryKeyErrorPropertyNotFound(
table.DisplayName(),
string.Join(CultureInfo.CurrentCulture.TextInfo.ListSeparator, unmappedColumns)));
return(null);
}
var keyBuilder = builder.HasKey(primaryKey.Columns.Select(GetPropertyName).ToArray());
if (primaryKey.Columns.Count == 1 &&
primaryKey.Columns[0].ValueGenerated == null &&
primaryKey.Columns[0].DefaultValueSql == null)
{
var property = builder.Metadata.FindProperty(GetPropertyName(primaryKey.Columns[0]))?.AsProperty();
if (property != null)
{
var dummyLogger = new DiagnosticsLogger <DbLoggerCategory.Model>(
new ScopedLoggerFactory(new LoggerFactory(), dispose: true),
new LoggingOptions(),
new DiagnosticListener(""));
var conventionalValueGenerated = new RelationalValueGeneratorConvention(dummyLogger).GetValueGenerated(property);
if (conventionalValueGenerated == ValueGenerated.OnAdd)
{
property.ValueGenerated = ValueGenerated.Never;
}
}
}
if (!string.IsNullOrEmpty(primaryKey.Name) &&
primaryKey.Name != ConstraintNamer.GetDefaultName(keyBuilder.Metadata))
{
keyBuilder.HasName(primaryKey.Name);
}
keyBuilder.Metadata.AddAnnotations(primaryKey.GetAnnotations());
return(keyBuilder);
}
public async Task Logs_commands_parameter_values(
Delegate commandDelegate,
string diagnosticName,
bool async)
{
var optionsExtension = new FakeRelationalOptionsExtension().WithConnectionString(ConnectionString);
var options = CreateOptions(optionsExtension);
var logFactory = new ListLoggerFactory();
var fakeConnection = new FakeRelationalConnection(options);
var logger = new DiagnosticsLogger <DbLoggerCategory.Database.Command>(
logFactory,
new FakeLoggingOptions(true),
new DiagnosticListener("Fake"),
new TestRelationalLoggingDefinitions());
var relationalCommand = CreateRelationalCommand(
commandText: "Logged Command",
parameters: new[]
{
new TypeMappedRelationalParameter(
"FirstInvariant", "FirstParameter", new IntTypeMapping("int", DbType.Int32), false)
});
var parameterValues = new Dictionary <string, object> {
{ "FirstInvariant", 17 }
};
if (async)
{
await((CommandFunc)commandDelegate)(fakeConnection, relationalCommand, parameterValues, logger);
}
else
{
((CommandAction)commandDelegate)(fakeConnection, relationalCommand, parameterValues, logger);
}
Assert.Equal(5, logFactory.Log.Count);
Assert.Equal(LogLevel.Debug, logFactory.Log[0].Level);
Assert.Equal(LogLevel.Debug, logFactory.Log[1].Level);
Assert.Equal(LogLevel.Warning, logFactory.Log[2].Level);
Assert.Equal(
CoreResources.LogSensitiveDataLoggingEnabled(new TestLogger <TestRelationalLoggingDefinitions>()).GenerateMessage(),
logFactory.Log[2].Message);
Assert.Equal(LogLevel.Information, logFactory.Log[3].Level);
Assert.Equal(LogLevel.Debug, logFactory.Log[4].Level);
foreach (var(_, _, message, _, _) in logFactory.Log.Skip(3))
{
Assert.EndsWith(
"[Parameters=[FirstParameter='17'], CommandType='0', CommandTimeout='30']" + _eol +
"Logged Command",
message);
}
}
protected ModelValidatorTest()
{
Log = new List <(LogLevel, EventId, string)>();
Logger = new DiagnosticsLogger <DbLoggerCategory.Model.Validation>(
new ListLoggerFactory(Log, l => l == DbLoggerCategory.Model.Validation.Name),
new LoggingOptions(),
new DiagnosticListener("Fake"));
}
public override IModelValidator CreateModelValidator(
DiagnosticsLogger <DbLoggerCategory.Model> modelLogger,
DiagnosticsLogger <DbLoggerCategory.Model.Validation> validationLogger)
=> new SqlServerModelValidator(
new ModelValidatorDependencies(validationLogger, modelLogger),
new RelationalModelValidatorDependencies(
new SqlServerTypeMappingSource(
TestServiceFactory.Instance.Create <TypeMappingSourceDependencies>(),
TestServiceFactory.Instance.Create <RelationalTypeMappingSourceDependencies>())));
public async Task Reports_command_diagnostic(
Delegate commandDelegate,
DbCommandMethod diagnosticName,
bool async)
{
var options = CreateOptions();
var fakeConnection = new FakeRelationalConnection(options);
var diagnostic = new List <Tuple <string, object> >();
var logger = new DiagnosticsLogger <DbLoggerCategory.Database.Command>(
new ListLoggerFactory(),
new FakeLoggingOptions(false),
new ListDiagnosticSource(diagnostic),
new TestRelationalLoggingDefinitions());
var relationalCommand = CreateRelationalCommand(
parameters: new[]
{
new TypeMappedRelationalParameter("FirstInvariant", "FirstParameter", new IntTypeMapping("int", DbType.Int32), false)
});
var parameterValues = new Dictionary <string, object>
{
{ "FirstInvariant", 17 }
};
if (async)
{
await((CommandFunc)commandDelegate)(fakeConnection, relationalCommand, parameterValues, logger);
}
else
{
((CommandAction)commandDelegate)(fakeConnection, relationalCommand, parameterValues, logger);
}
Assert.Equal(4, diagnostic.Count);
Assert.Equal(RelationalEventId.CommandCreating.Name, diagnostic[0].Item1);
Assert.Equal(RelationalEventId.CommandCreated.Name, diagnostic[1].Item1);
Assert.Equal(RelationalEventId.CommandExecuting.Name, diagnostic[2].Item1);
Assert.Equal(RelationalEventId.CommandExecuted.Name, diagnostic[3].Item1);
var beforeData = (CommandEventData)diagnostic[2].Item2;
var afterData = (CommandExecutedEventData)diagnostic[3].Item2;
Assert.Equal(fakeConnection.DbConnections[0].DbCommands[0], beforeData.Command);
Assert.Equal(fakeConnection.DbConnections[0].DbCommands[0], afterData.Command);
Assert.Equal(diagnosticName, beforeData.ExecuteMethod);
Assert.Equal(diagnosticName, afterData.ExecuteMethod);
Assert.Equal(async, beforeData.IsAsync);
Assert.Equal(async, afterData.IsAsync);
}
public ConventionSet CreateConventionalConventionSet(
DiagnosticsLogger <DbLoggerCategory.Model> modelLogger,
DiagnosticsLogger <DbLoggerCategory.Model.Validation> validationLogger)
{
var contextServices = CreateContextServices(
new ServiceCollection()
.AddScoped <IDiagnosticsLogger <DbLoggerCategory.Model> >(_ => modelLogger)
.AddScoped <IDiagnosticsLogger <DbLoggerCategory.Model.Validation> >(_ => validationLogger));
return(contextServices.GetRequiredService <IConventionSetBuilder>().CreateConventionSet());
}
private DiagnosticsLogger <DbLoggerCategory.Database.Transaction> CreateLogger()
{
var options = new LoggingOptions();
options.Initialize(new DbContextOptionsBuilder().ConfigureWarnings(w => w.Default(WarningBehavior.Throw)).Options);
var logger = new DiagnosticsLogger <DbLoggerCategory.Database.Transaction>(
new ListLoggerFactory(l => false),
options,
new DiagnosticListener("Fake"));
return(logger);
}
public override IModelValidator CreateModelValidator(
DiagnosticsLogger <DbLoggerCategory.Model> modelLogger,
DiagnosticsLogger <DbLoggerCategory.Model.Validation> validationLogger)
=> new SqliteModelValidator(
new ModelValidatorDependencies(validationLogger, modelLogger),
new RelationalModelValidatorDependencies(
#pragma warning disable 618
TestServiceFactory.Instance.Create <ObsoleteRelationalTypeMapper>(),
#pragma warning restore 618
new SqliteTypeMappingSource(
TestServiceFactory.Instance.Create <TypeMappingSourceDependencies>(),
TestServiceFactory.Instance.Create <RelationalTypeMappingSourceDependencies>())));
public DiagnosticsLoggerTest()
{
this.mockHttpClient = new Mock <IHttpClient>();
this.mockLogger = new Mock <ILogger>();
this.target = new DiagnosticsLogger(
this.mockHttpClient.Object,
new ServicesConfig
{
DiagnosticsEndpointUrl = DIAGNOSTICS_SERVICE_URL
},
this.mockLogger.Object);
}
private DiagnosticsLogger <DbLoggerCategory.Model> CreateLogger()
{
ListLoggerFactory.Clear();
var options = new LoggingOptions();
options.Initialize(new DbContextOptionsBuilder().EnableSensitiveDataLogging(false).Options);
var modelLogger = new DiagnosticsLogger <DbLoggerCategory.Model>(
ListLoggerFactory,
options,
new DiagnosticListener("Fake"));
return(modelLogger);
}
public void SimpleUsage()
{
DiagnosticsLogger logger = new DiagnosticsLogger("castle_testlog", "test_source");
logger.Warn("my message");
logger.Error("my other message", new Exception("Bad, bad exception"));
EventLog log = new EventLog();
log.Log = "castle_testlog";
log.MachineName = ".";
Assert.AreEqual(2, log.Entries.Count);
}
public ModelBuilder CreateConventionBuilder(
DiagnosticsLogger <DbLoggerCategory.Model> modelLogger,
DiagnosticsLogger <DbLoggerCategory.Model.Validation> validationLogger)
{
var contextServices = CreateContextServices(
new ServiceCollection()
.AddScoped <IDiagnosticsLogger <DbLoggerCategory.Model> >(_ => modelLogger)
.AddScoped <IDiagnosticsLogger <DbLoggerCategory.Model.Validation> >(_ => validationLogger));
return(new ModelBuilder(
contextServices.GetRequiredService <IConventionSetBuilder>().CreateConventionSet(),
contextServices.GetRequiredService <ModelDependencies>().With(modelLogger)));
}
public async Task Logs_commands_without_parameter_values(
Delegate commandDelegate,
string diagnosticName,
bool async)
{
var options = CreateOptions();
var logFactory = new ListLoggerFactory();
var fakeConnection = new FakeRelationalConnection(options);
var logger = new DiagnosticsLogger <DbLoggerCategory.Database.Command>(
logFactory,
new FakeLoggingOptions(false),
new DiagnosticListener("Fake"),
new TestRelationalLoggingDefinitions());
var relationalCommand = CreateRelationalCommand(
commandText: "Logged Command",
parameters: new[]
{
new TypeMappedRelationalParameter("FirstInvariant", "FirstParameter", new IntTypeMapping("int", DbType.Int32), false)
});
var parameterValues = new Dictionary <string, object>
{
{ "FirstInvariant", 17 }
};
if (async)
{
await((CommandFunc)commandDelegate)(fakeConnection, relationalCommand, parameterValues, logger);
}
else
{
((CommandAction)commandDelegate)(fakeConnection, relationalCommand, parameterValues, logger);
}
Assert.Equal(2, logFactory.Log.Count);
Assert.Equal(LogLevel.Debug, logFactory.Log[0].Level);
Assert.Equal(LogLevel.Debug, logFactory.Log[1].Level);
foreach (var(_, _, message, _, _) in logFactory.Log)
{
Assert.EndsWith(
"[Parameters=[FirstParameter='?' (DbType = Int32)], CommandType='0', CommandTimeout='30']" + _eol +
"Logged Command",
message);
}
}
public void SimpleUsage()
{
DiagnosticsLogger logger = new DiagnosticsLogger("castle_testlog", "test_source");
logger.Warn("my message");
logger.Error("my other message", new Exception("Bad, bad exception"));
EventLog log = new EventLog();
log.Log = "castle_testlog";
log.MachineName = ".";
Assert.AreEqual(2, log.Entries.Count);
}
public ModelBuilder CreateConventionBuilder(
DiagnosticsLogger <DbLoggerCategory.Model> modelLogger,
DiagnosticsLogger <DbLoggerCategory.Model.Validation> validationLogger)
{
var contextServices = CreateContextServices();
var conventionSet = new CoreConventionSetBuilder(
contextServices.GetRequiredService <CoreConventionSetBuilderDependencies>().With(modelLogger))
.CreateConventionSet();
conventionSet = new CompositeConventionSetBuilder(
contextServices.GetRequiredService <IEnumerable <IConventionSetBuilder> >().ToList())
.AddConventions(conventionSet);
conventionSet.ModelBuiltConventions.Add(new ValidatingConvention(CreateModelValidator(modelLogger, validationLogger)));
return(new ModelBuilder(conventionSet));
}
public ModelBuilder CreateConventionBuilder(
DiagnosticsLogger <DbLoggerCategory.Model> modelLogger,
DiagnosticsLogger <DbLoggerCategory.Model.Validation> validationLogger)
{
var contextServices = CreateContextServices(
new ServiceCollection()
.AddScoped <IDiagnosticsLogger <DbLoggerCategory.Model> >(_ => modelLogger)
.AddScoped <IDiagnosticsLogger <DbLoggerCategory.Model.Validation> >(_ => validationLogger));
var conventionSet = contextServices.GetRequiredService <IConventionSetBuilder>().CreateConventionSet();
conventionSet.ModelBuiltConventions.Add(
new ValidatingConvention(
CreateModelValidator(),
validationLogger));
return(new ModelBuilder(conventionSet));
}
public async Task LogOperationAsyncTestAsync()
{
var serviceProvider = BuildServiceProvider();
var db = serviceProvider.GetRequiredService <IDiagnosticsDbContext>();
var http = serviceProvider.GetRequiredService <IHttpContextAccessor>();
var principal = PrincipalUser.Personate(1, "Someone", serviceProvider);
var logger = new DiagnosticsLogger(db, http, principal);
//log an operation
await logger.LogOperationAsync(LogLevel.Trace, "UnitTest");
Assert.AreEqual(1, db.OperationLogs.Count());
var findRow = db.OperationLogs.FirstOrDefault(x => x.Message == "UnitTest");
var rowId = findRow.Id;
Assert.IsNotNull(findRow);
Assert.AreEqual(1, findRow.Repeated);
Assert.AreEqual(LogLevel.Trace, findRow.LogLevel);
Assert.AreEqual(principal.Id, findRow.UserId);
Assert.AreEqual(principal.AnonymousId, findRow.AnonymousId);
Assert.AreEqual(principal.DisplayName, findRow.UserName);
//log the same message one more time, should be still only 1 row
await logger.LogOperationAsync(LogLevel.Trace, "UnitTest");
Assert.AreEqual(1, db.OperationLogs.Count());
//find back the row, the Repeated value should be 2 now
findRow = db.OperationLogs.Find(rowId);
Assert.AreEqual(2, findRow.Repeated);
//log some different operations
await logger.LogOperationAsync(LogLevel.Warning, "Make a difference");
await logger.LogOperationAsync(LogLevel.Warning, "Again");
await logger.LogOperationAsync(LogLevel.Warning, "One more time");
Assert.AreEqual(4, db.OperationLogs.Count());
db.Normalize().Database.EnsureDeleted();
}
protected TestModelBuilder(TestHelpers testHelpers)
{
var options = new LoggingOptions();
options.Initialize(new DbContextOptionsBuilder().EnableSensitiveDataLogging(false).Options);
ValidationLoggerFactory = new ListLoggerFactory(l => l == DbLoggerCategory.Model.Validation.Name);
var validationLogger = new DiagnosticsLogger <DbLoggerCategory.Model.Validation>(
ValidationLoggerFactory,
options,
new DiagnosticListener("Fake"));
ModelLoggerFactory = new ListLoggerFactory(l => l == DbLoggerCategory.Model.Name);
var modelLogger = new DiagnosticsLogger <DbLoggerCategory.Model>(
ModelLoggerFactory,
options,
new DiagnosticListener("Fake"));
ModelBuilder = testHelpers.CreateConventionBuilder(modelLogger, validationLogger);
}
public DatabaseModel CreateModel(string dbName, string sql, IEnumerable <string> tables, IEnumerable <string> schemas, bool executeScript = false)
{
if (executeScript)
{
MySQLTestStore.ExecuteScript(sql);
}
else
{
MySQLTestStore.Execute(sql);
}
_logger = new DiagnosticsLogger <DbLoggerCategory.Scaffolding>(
ListLoggerFactory,
new LoggingOptions(),
new DiagnosticListener("Fake"),
new MySQLLoggingDefinitions());
return(new MySQLDatabaseModelFactory(_logger, options).
Create(MySQLTestStore.rootConnectionString + ";database=" + dbName + ";",
new DatabaseModelFactoryOptions(tables, schemas)));
}
internal static (string, IEnumerable <SqlParameter>) ToParametrizedSql <TEntity>(this IQueryable <TEntity> query) where TEntity : class
{
var queryCompiler = (QueryCompiler)QueryCompilerField.GetValue(query.Provider);
var modelGenerator = (QueryModelGenerator)QueryModelGeneratorField.GetValue(queryCompiler);
var parameterValues = new SimpleParameterValues();
var diagnosticsLogger = new DiagnosticsLogger <DbLoggerCategory.Query>(new LoggerFactory(), null, new DiagnosticListener("Temp"));
var parameterExpression = modelGenerator.ExtractParameters(diagnosticsLogger, query.Expression, parameterValues);
var queryModel = modelGenerator.ParseQuery(parameterExpression);
var database = (IDatabase)DataBaseField.GetValue(queryCompiler);
var databaseDependencies = (DatabaseDependencies)DatabaseDependenciesField.GetValue(database);
var queryCompilationContext = databaseDependencies.QueryCompilationContextFactory.Create(false);
var modelVisitor = (RelationalQueryModelVisitor)queryCompilationContext.CreateQueryModelVisitor();
modelVisitor.CreateQueryExecutor <TEntity>(queryModel);
//modelVisitor.CreateAsyncQueryExecutor<TEntity>(queryModel);
// CreateAsync not used, throws: Message: System.ArgumentException : Expression of type 'System.Collections.Generic.IEnumerable`1[EFCore.BulkExtensions.Tests.Item]'
// cannot be used for return type 'System.Collections.Generic.IAsyncEnumerable`1[EFCore.BulkExtensions.Tests.Item]'
string sql = modelVisitor.Queries.First().ToString();
return(sql, parameterValues.ParameterValues.Select(x => new SqlParameter(x.Key, x.Value)));
}
private void FilterTest(Func <string, bool> filter, params string[] expected)
{
var loggerFactory = new LoggerFactory();
var loggerProvider = new TestLoggerProvider(filter);
loggerFactory.AddProvider(loggerProvider);
var dbLogger = new DiagnosticsLogger <DbLoggerCategory.Database>(loggerFactory, new LoggingOptions(), new DiagnosticListener("Fake"));
var sqlLogger = new DiagnosticsLogger <DbLoggerCategory.Database.Command>(loggerFactory, new LoggingOptions(), new DiagnosticListener("Fake"));
var queryLogger = new DiagnosticsLogger <DbLoggerCategory.Query>(loggerFactory, new LoggingOptions(), new DiagnosticListener("Fake"));
var randomLogger = loggerFactory.CreateLogger("Random");
dbLogger.Logger.LogInformation(1, "DB1");
sqlLogger.Logger.LogInformation(2, "SQL1");
queryLogger.Logger.LogInformation(3, "Query1");
randomLogger.LogInformation(4, "Random1");
dbLogger.Logger.LogInformation(1, "DB2");
sqlLogger.Logger.LogInformation(2, "SQL2");
queryLogger.Logger.LogInformation(3, "Query2");
randomLogger.LogInformation(4, "Random2");
Assert.Equal(loggerProvider.Messages, expected);
}
public async Task LogExceptionAsyncTestAsync()
{
var serviceProvider = BuildServiceProvider();
var db = serviceProvider.GetRequiredService <IDiagnosticsDbContext>();
var http = serviceProvider.GetRequiredService <IHttpContextAccessor>();
var anonymous = PrincipalUser.Personate(0, "Anonymous", serviceProvider);
var logger = new DiagnosticsLogger(db, http, anonymous);
var exception = new Exception("Oops");
//insert exception log should be successful, the PrincipalUser is anonymous
await logger.LogExceptionAsync(exception);
Assert.AreEqual(1, db.ExceptionLogs.Count());
//exception data should be written to the fields
var findRow = db.ExceptionLogs.SingleOrDefault(x => x.Message == exception.Message);
var rowId = findRow.Id;
Assert.IsNotNull(findRow);
Assert.AreEqual(1, findRow.Repeated);
Assert.AreEqual(exception.GetType().Name, findRow.ExceptionType);
Assert.AreEqual(exception.StackTrace, findRow.StackTrace);
Assert.AreEqual(exception.Source, findRow.Source);
Assert.AreEqual(anonymous.Id, findRow.UserId);
Assert.AreEqual(anonymous.AnonymousId, findRow.AnonymousId);
Assert.AreEqual(anonymous.DisplayName, findRow.UserName);
//log the same exception again, should be still only 1 exception log record
await logger.LogExceptionAsync(exception);
Assert.AreEqual(1, db.ExceptionLogs.Count());
//find back the row, the Repeated value should be 2 now
findRow = db.ExceptionLogs.Find(rowId);
Assert.AreEqual(2, findRow.Repeated);
//log the same exception with a known user this time
var someone = PrincipalUser.Personate(1, "Someone", serviceProvider);
logger = new DiagnosticsLogger(db, http, someone);
//a new row should be inserted and there should be 2 rows in total
await logger.LogExceptionAsync(exception);
findRow = db.ExceptionLogs.SingleOrDefault(x => x.Message == exception.Message && x.UserId == someone.Id);
Assert.AreEqual(2, db.ExceptionLogs.Count());
Assert.IsNotNull(findRow);
Assert.AreEqual(1, findRow.Repeated);
Assert.AreEqual(someone.Id, findRow.UserId);
Assert.AreEqual(someone.AnonymousId, findRow.AnonymousId);
Assert.AreEqual(someone.DisplayName, findRow.UserName);
//log a different exception
exception = new InvalidOperationException("Boom");
await logger.LogExceptionAsync(exception);
//another new row should be inserted and there should be 3 rows in total
findRow = db.ExceptionLogs.SingleOrDefault(x => x.Message == exception.Message);
Assert.AreEqual(3, db.ExceptionLogs.Count());
Assert.IsNotNull(findRow);
Assert.AreEqual(1, findRow.Repeated);
Assert.AreEqual(exception.Source, findRow.Source);
Assert.AreEqual(exception.GetType().Name, findRow.ExceptionType);
Assert.AreEqual(exception.StackTrace, findRow.StackTrace);
Assert.AreEqual(exception.Source, findRow.Source);
Assert.AreEqual(someone.Id, findRow.UserId);
Assert.AreEqual(someone.AnonymousId, findRow.AnonymousId);
Assert.AreEqual(someone.DisplayName, findRow.UserName);
db.Normalize().Database.EnsureDeleted();
}
public ModelBuilder CreateConventionBuilder(
DiagnosticsLogger <DbLoggerCategory.Model> modelLogger,
DiagnosticsLogger <DbLoggerCategory.Model.Validation> validationLogger)
=> new ModelBuilder(CreateConventionalConventionSet(modelLogger, validationLogger));
public virtual IModelValidator CreateModelValidator(
DiagnosticsLogger <DbLoggerCategory.Model> modelLogger,
DiagnosticsLogger <DbLoggerCategory.Model.Validation> validationLogger)
=> new ModelValidator(new ModelValidatorDependencies(validationLogger, modelLogger));
private void GenerateProperty(IProperty property, bool useDataAnnotations)
{
var lines = new List <string>
{
$".{nameof(EntityTypeBuilder.Property)}(e => e.{property.Name})"
};
var annotations = property.GetAnnotations().ToList();
RemoveAnnotation(ref annotations, RelationalAnnotationNames.ColumnName);
RemoveAnnotation(ref annotations, RelationalAnnotationNames.ColumnType);
RemoveAnnotation(ref annotations, CoreAnnotationNames.MaxLength);
RemoveAnnotation(ref annotations, CoreAnnotationNames.TypeMapping);
RemoveAnnotation(ref annotations, CoreAnnotationNames.Unicode);
RemoveAnnotation(ref annotations, RelationalAnnotationNames.DefaultValue);
RemoveAnnotation(ref annotations, RelationalAnnotationNames.DefaultValueSql);
RemoveAnnotation(ref annotations, RelationalAnnotationNames.ComputedColumnSql);
RemoveAnnotation(ref annotations, RelationalAnnotationNames.IsFixedLength);
RemoveAnnotation(ref annotations, ScaffoldingAnnotationNames.ColumnOrdinal);
if (!useDataAnnotations)
{
if (!property.IsNullable &&
property.ClrType.IsNullableType() &&
!property.IsPrimaryKey())
{
lines.Add($".{nameof(PropertyBuilder.IsRequired)}()");
}
var columnName = property.Relational().ColumnName;
if (columnName != null &&
columnName != property.Name)
{
lines.Add(
$".{nameof(RelationalPropertyBuilderExtensions.HasColumnName)}" +
$"({_code.Literal(columnName)})");
}
var columnType = property.GetConfiguredColumnType();
if (columnType != null)
{
lines.Add(
$".{nameof(RelationalPropertyBuilderExtensions.HasColumnType)}" +
$"({_code.Literal(columnType)})");
}
var maxLength = property.GetMaxLength();
if (maxLength.HasValue)
{
lines.Add(
$".{nameof(PropertyBuilder.HasMaxLength)}" +
$"({_code.Literal(maxLength.Value)})");
}
}
if (property.IsUnicode() != null)
{
lines.Add(
$".{nameof(PropertyBuilder.IsUnicode)}" +
$"({(property.IsUnicode() == false ? "false" : "")})");
}
if (property.Relational().IsFixedLength)
{
lines.Add(
$".{nameof(RelationalPropertyBuilderExtensions.IsFixedLength)}()");
}
if (property.Relational().DefaultValue != null)
{
lines.Add(
$".{nameof(RelationalPropertyBuilderExtensions.HasDefaultValue)}" +
$"({_code.UnknownLiteral(property.Relational().DefaultValue)})");
}
if (property.Relational().DefaultValueSql != null)
{
lines.Add(
$".{nameof(RelationalPropertyBuilderExtensions.HasDefaultValueSql)}" +
$"({_code.Literal(property.Relational().DefaultValueSql)})");
}
if (property.Relational().ComputedColumnSql != null)
{
lines.Add(
$".{nameof(RelationalPropertyBuilderExtensions.HasComputedColumnSql)}" +
$"({_code.Literal(property.Relational().ComputedColumnSql)})");
}
var dummyLogger = new DiagnosticsLogger <DbLoggerCategory.Model>(
new ScopedLoggerFactory(new LoggerFactory(), dispose: true),
new LoggingOptions(),
new DiagnosticListener(""),
new LoggingDefinitions());
var valueGenerated = property.ValueGenerated;
var isRowVersion = false;
if (((Property)property).GetValueGeneratedConfigurationSource().HasValue &&
new RelationalValueGeneratorConvention(dummyLogger).GetValueGenerated((Property)property) != valueGenerated)
{
string methodName;
switch (valueGenerated)
{
case ValueGenerated.OnAdd:
methodName = nameof(PropertyBuilder.ValueGeneratedOnAdd);
break;
case ValueGenerated.OnAddOrUpdate:
isRowVersion = property.IsConcurrencyToken;
methodName = isRowVersion
? nameof(PropertyBuilder.IsRowVersion)
: nameof(PropertyBuilder.ValueGeneratedOnAddOrUpdate);
break;
case ValueGenerated.Never:
methodName = nameof(PropertyBuilder.ValueGeneratedNever);
break;
default:
methodName = "";
break;
}
lines.Add($".{methodName}()");
}
if (property.IsConcurrencyToken &&
!isRowVersion)
{
lines.Add($".{nameof(PropertyBuilder.IsConcurrencyToken)}()");
}
var annotationsToRemove = new List <IAnnotation>();
foreach (var annotation in annotations)
{
if (annotation.Value == null ||
_annotationCodeGenerator.IsHandledByConvention(property, annotation))
{
annotationsToRemove.Add(annotation);
}
else
{
var methodCall = _annotationCodeGenerator.GenerateFluentApi(property, annotation);
if (methodCall != null)
{
lines.Add(_code.Fragment(methodCall));
annotationsToRemove.Add(annotation);
}
}
}
lines.AddRange(GenerateAnnotations(annotations.Except(annotationsToRemove)));
switch (lines.Count)
{
case 1:
return;
case 2:
lines = new List <string>
{
lines[0] + lines[1]
};
break;
}
AppendMultiLineFluentApi(property.DeclaringEntityType, lines);
}
/// <summary>
/// Log Diagnostic Message
/// </summary>
/// <param name="baseLogInfo"></param>
public void LogMessage <T>(T baseLogInfo) where T : BaseLogInfo
{
ILogStrategy <T> logStrategy = new DiagnosticsLogger <T>();
ILogMessage messageCode = LogWriter <T> .Write(logStrategy, baseLogInfo);
}
public async Task Reports_command_diagnostic_on_exception(
Delegate commandDelegate,
DbCommandMethod diagnosticName,
bool async)
{
var exception = new InvalidOperationException();
var fakeDbConnection = new FakeDbConnection(
ConnectionString,
new FakeCommandExecutor(
c => throw exception,
c => throw exception,
(c, cb) => throw exception,
(c, ct) => throw exception,
(c, ct) => throw exception,
(c, cb, ct) => throw exception));
var optionsExtension = new FakeRelationalOptionsExtension().WithConnection(fakeDbConnection);
var options = CreateOptions(optionsExtension);
var diagnostic = new List <Tuple <string, object> >();
var fakeConnection = new FakeRelationalConnection(options);
var logger = new DiagnosticsLogger <DbLoggerCategory.Database.Command>(
new ListLoggerFactory(),
new FakeLoggingOptions(false),
new ListDiagnosticSource(diagnostic),
new TestRelationalLoggingDefinitions());
var relationalCommand = CreateRelationalCommand(
parameters: new[]
{
new TypeMappedRelationalParameter("FirstInvariant", "FirstParameter", new IntTypeMapping("int", DbType.Int32), false)
});
var parameterValues = new Dictionary <string, object>
{
{ "FirstInvariant", 17 }
};
if (async)
{
await Assert.ThrowsAsync <InvalidOperationException>(
async()
=> await((CommandFunc)commandDelegate)(fakeConnection, relationalCommand, parameterValues, logger));
}
else
{
Assert.Throws <InvalidOperationException>(
()
=> ((CommandAction)commandDelegate)(fakeConnection, relationalCommand, parameterValues, logger));
}
Assert.Equal(2, diagnostic.Count);
Assert.Equal(RelationalEventId.CommandExecuting.Name, diagnostic[0].Item1);
Assert.Equal(RelationalEventId.CommandError.Name, diagnostic[1].Item1);
var beforeData = (CommandEventData)diagnostic[0].Item2;
var afterData = (CommandErrorEventData)diagnostic[1].Item2;
Assert.Equal(fakeDbConnection.DbCommands[0], beforeData.Command);
Assert.Equal(fakeDbConnection.DbCommands[0], afterData.Command);
Assert.Equal(diagnosticName, beforeData.ExecuteMethod);
Assert.Equal(diagnosticName, afterData.ExecuteMethod);
Assert.Equal(async, beforeData.IsAsync);
Assert.Equal(async, afterData.IsAsync);
Assert.Equal(exception, afterData.Exception);
}
private static IHistoryRepository CreateHistoryRepository()
{
var optionsBuilder = new DbContextOptionsBuilder();
optionsBuilder.UseMySQL(MySQLTestStore.rootConnectionString + "database=test;");
var connection = new MySQLServerConnection(optionsBuilder.Options, new Logger <MySQLServerConnection>(new LoggerFactory()));
var typeMapper = new MySQLTypeMapper();
var serviceCollection = new ServiceCollection();
serviceCollection.AddEntityFrameworkMySQL()
.AddDbContext <MyTestContext>();
var serviceProvider = serviceCollection.BuildServiceProvider();
var context = serviceProvider.GetRequiredService <MyTestContext>();
var creator = context.GetService <IRelationalDatabaseCreator>();
var cmdBuilder = context.GetService <IRawSqlCommandBuilder>();
var options = new DbContextOptions <DbContext>(
new Dictionary <Type, IDbContextOptionsExtension>
{
{
typeof(MySQLOptionsExtension),
new MySQLOptionsExtension()
}
});
var modelDiffer = new MigrationsModelDiffer(
new MySQLTypeMapper(),
new MySQLMigrationsAnnotationProvider(
new MigrationsAnnotationProviderDependencies()));
var logger = new DiagnosticsLogger <DbLoggerCategory.Database.Command>(
new LoggerFactory(),
new LoggingOptions(),
new DiagnosticListener("Fake"));
var commandBuilderFactory = new RelationalCommandBuilderFactory(
logger,
typeMapper);
var sqlGeneratorHelper = new MySQLSqlGenerationHelper(new RelationalSqlGenerationHelperDependencies());
var migrationsSqlGeneratorDependencies = new MigrationsSqlGeneratorDependencies(
commandBuilderFactory,
sqlGeneratorHelper,
typeMapper);
var migrationsSqlGeneratior = new MySQLMigrationsSqlGenerator(migrationsSqlGeneratorDependencies);
HistoryRepositoryDependencies dependencies = new HistoryRepositoryDependencies(
creator,
cmdBuilder,
connection,
options,
modelDiffer,
migrationsSqlGeneratior,
sqlGeneratorHelper);
return(new MySQLHistoryRepository(dependencies));
}
