public void Test_SaveChangesInterceptor_MultiThread(int threads)
{
var locker = new object();
var inserted = new List <AuditEventEntityFramework>();
Audit.Core.Configuration.Setup()
.UseDynamicProvider(_ => _
.OnInsert(ev =>
{
lock (locker)
{
inserted.Add(AuditEvent.FromJson <AuditEventEntityFramework>(ev.ToJson()));
}
}));
Audit.EntityFramework.Configuration.Setup()
.ForContext <InterceptContext>(_ => _
.AuditEventType("{context}**")
.IncludeEntityObjects(true));
using (var ctx = new InterceptContext(new DbContextOptionsBuilder().Options))
{
ctx.Database.EnsureDeleted();
ctx.Database.EnsureCreated();
}
Action <int> insertAction = (int index) =>
{
var guid = Guid.NewGuid().ToString();
var dept = new InterceptContext.Department()
{
Id = index, Name = guid, Comments = "test"
};
using (var ctx = new InterceptContext(new DbContextOptionsBuilder().AddInterceptors(new AuditSaveChangesInterceptor()).Options))
{
ctx.Departments.Add(dept);
ctx.SaveChanges();
}
};
var tasks = new List <Task>();
for (int i = 0; i < threads; i++)
{
int a = i;
tasks.Add(Task.Run(() => insertAction(a)));
}
Task.WaitAll(tasks.ToArray());
Assert.AreEqual(threads, inserted.Count);
Assert.AreEqual("InterceptContext**", inserted[0].EventType);
Assert.AreEqual(true, inserted[0].EntityFrameworkEvent.Success);
Assert.AreEqual(1, inserted[0].EntityFrameworkEvent.Entries.Count);
Assert.AreEqual("Insert", inserted[0].EntityFrameworkEvent.Entries[0].Action);
Assert.AreEqual(3, inserted[0].EntityFrameworkEvent.Entries[0].ColumnValues.Count);
Assert.AreEqual("test", inserted[0].EntityFrameworkEvent.Entries[0].ColumnValues["Comments"].ToString());
Assert.IsTrue(Enumerable.Range(0, threads).All(i => inserted.Any(ev => ev.EntityFrameworkEvent.Entries[0].PrimaryKey["Id"].ToString() == i.ToString())));
}
public async Task Test_CreationPolicyAync()
{
var inserts = new List <AuditEvent>();
var replaces = new List <AuditEvent>();
Audit.Core.Configuration.Setup()
.Use(config => config.OnInsert(ev =>
{
inserts.Add(AuditEvent.FromJson(ev.ToJson()));
})
.OnReplace((id, ev) =>
{
replaces.Add(AuditEvent.FromJson(ev.ToJson()));
}))
.WithCreationPolicy(EventCreationPolicy.InsertOnStartReplaceOnEnd);
var real = new InterceptMe("test");
var audited = AuditProxy.Create <InterceptMeBase>(real);
var res = await audited.AsyncFunctionAsync("2000");
Assert.AreEqual("ok", res);
Assert.AreEqual(1, inserts.Count);
Assert.AreEqual(1, replaces.Count);
Assert.IsNull(inserts[0].GetAuditInterceptEvent().Result);
Assert.AreEqual("Task<String>", replaces[0].GetAuditInterceptEvent().Result.Type);
Assert.AreEqual("ok", replaces[0].GetAuditInterceptEvent().Result.Value.ToString());
}
public override async Task <T> GetEventAsync <T>(object eventId)
{
if (JsonColumnNameBuilder == null)
{
return(null);
}
using (var ctx = CreateContext(null))
{
var cmdText = GetSelectCommandText(null);
#if NET45
var result = ctx.Database.SqlQuery <string>(cmdText, new SqlParameter("@eventId", eventId));
var json = await result.FirstOrDefaultAsync();
#elif NETSTANDARD1_3
var result = ctx.FakeIdSet.FromSql(cmdText, new SqlParameter("@eventId", eventId));
var json = (await result.FirstOrDefaultAsync())?.Id;
#elif NETSTANDARD2_0 || NETSTANDARD2_1
var result = ctx.FakeIdSet.FromSqlRaw(cmdText, new SqlParameter("@eventId", eventId));
var json = (await result.FirstOrDefaultAsync())?.Id;
#endif
if (json != null)
{
return(AuditEvent.FromJson <T>(json));
}
}
return(null);
}
public void Test_DbCommandInterceptor_CreationPolicy()
{
var inserted = new List <AuditEventCommandEntityFramework>();
var replaced = new List <AuditEventCommandEntityFramework>();
Audit.Core.Configuration.Setup()
.UseDynamicProvider(_ => _
.OnInsert(ev => inserted.Add(AuditEvent.FromJson <AuditEventCommandEntityFramework>(ev.ToJson())))
.OnReplace((eventId, ev) =>
replaced.Add(AuditEvent.FromJson <AuditEventCommandEntityFramework>(ev.ToJson()))))
.WithCreationPolicy(EventCreationPolicy.InsertOnStartReplaceOnEnd);
Audit.EntityFramework.Configuration.Setup()
.ForContext <DbCommandInterceptContext>(_ => _
.IncludeEntityObjects(true));
int id = new Random().Next();
using (var ctx = new DbCommandInterceptContext(new DbContextOptionsBuilder()
.AddInterceptors(new AuditCommandInterceptor()).Options))
{
//NonQueryExecuting
var result = ctx.Database.ExecuteSqlRaw("INSERT INTO DEPARTMENTS (Id, Name, Comments) VALUES (" + id + ", 'test', {0})", "comments");
Assert.AreEqual(1, result);
}
Assert.AreEqual(1, inserted.Count);
Assert.AreEqual(1, replaced.Count);
}
public async Task Test_SaveChangesInterceptor_FailureAsync()
{
var inserted = new List <AuditEventEntityFramework>();
var replaced = new List <AuditEventEntityFramework>();
Audit.Core.Configuration.Setup()
.UseDynamicProvider(_ => _
.OnInsert(ev => inserted.Add(AuditEvent.FromJson <AuditEventEntityFramework>(ev.ToJson())))
.OnReplace((id, ev) => replaced.Add(AuditEvent.FromJson <AuditEventEntityFramework>(ev.ToJson()))));
Audit.EntityFramework.Configuration.Setup()
.ForContext <InterceptContext>(_ => _
.AuditEventType("{context}**")
.IncludeEntityObjects(true));
var dept = new InterceptContext.Department()
{
Id = 1, Name = "test", Comments = "test"
};
using (var ctx = new InterceptContext(new DbContextOptionsBuilder().Options))
{
// not intercepted
await ctx.Database.EnsureDeletedAsync();
await ctx.Database.EnsureCreatedAsync();
await ctx.Departments.AddAsync(dept);
await ctx.SaveChangesAsync();
}
Assert.AreEqual(0, inserted.Count);
var guid = Guid.NewGuid().ToString();
dept.Name = guid;
using (var ctx = new InterceptContext(new DbContextOptionsBuilder().AddInterceptors(new AuditSaveChangesInterceptor()).Options))
{
await ctx.Departments.AddAsync(dept);
try
{
await ctx.SaveChangesAsync();
}
catch (ArgumentException ex)
{
Assert.IsTrue(ex.Message.Contains("item with the same key"));
}
}
Assert.AreEqual(1, inserted.Count);
Assert.AreEqual(0, replaced.Count);
Assert.AreEqual("InterceptContext**", inserted[0].EventType);
Assert.AreEqual(false, inserted[0].EntityFrameworkEvent.Success);
Assert.IsTrue(inserted[0].EntityFrameworkEvent.ErrorMessage.Contains("item with the same key"));
Assert.AreEqual(1, inserted[0].EntityFrameworkEvent.Entries.Count);
Assert.IsTrue(inserted[0].EntityFrameworkEvent.Entries[0].Entity.ToString().Contains(guid));
Assert.AreEqual("Insert", inserted[0].EntityFrameworkEvent.Entries[0].Action);
Assert.AreEqual(3, inserted[0].EntityFrameworkEvent.Entries[0].ColumnValues.Count);
Assert.AreEqual(guid, inserted[0].EntityFrameworkEvent.Entries[0].ColumnValues["Name"].ToString());
}
public void Test_DbCommandInterceptor_IgnoreParams()
{
var inserted = new List <AuditEventCommandEntityFramework>();
Audit.Core.Configuration.Setup()
.UseDynamicProvider(_ => _
.OnInsert(ev => inserted.Add(AuditEvent.FromJson <AuditEventCommandEntityFramework>(ev.ToJson()))))
.WithCreationPolicy(EventCreationPolicy.InsertOnEnd);
Audit.EntityFramework.Configuration.Setup()
.ForContext <DbCommandInterceptContext>(_ => _
.IncludeEntityObjects(true));
using (var ctx = new DbCommandInterceptContext(new DbContextOptionsBuilder().Options))
{
ctx.Database.EnsureCreated();
}
var interceptor = new AuditCommandInterceptor()
{
LogParameterValues = false
};
using (var ctx = new DbCommandInterceptContext(new DbContextOptionsBuilder().AddInterceptors(interceptor).Options))
{
//NonQueryExecuting
var result = ctx.Database.ExecuteSqlRaw("SELECT {0}", "test");
}
Assert.AreEqual(1, inserted.Count);
Assert.IsNull(inserted[0].CommandEvent.Parameters);
}
public override T GetEvent <T>(object eventId)
{
if (JsonColumnNameBuilder == null)
{
return(null);
}
using (var ctx = new AuditContext(ConnectionStringBuilder?.Invoke(null)))
{
var cmdText = GetSelectCommandText(null);
#if NET45
var result = ctx.Database.SqlQuery <string>(cmdText, new SqlParameter("@eventId", eventId));
var json = result.FirstOrDefault();
#elif NETSTANDARD1_3 || NETSTANDARD2_0
var result = ctx.FakeIdSet.FromSql(cmdText, new SqlParameter("@eventId", eventId));
var json = result.FirstOrDefault()?.Id;
#elif NETSTANDARD2_1
var result = ctx.FakeIdSet.FromSqlRaw(cmdText, new SqlParameter("@eventId", eventId));
var json = result.FirstOrDefault()?.Id;
#endif
if (json != null)
{
return(AuditEvent.FromJson <T>(json));
}
}
return(null);
}
public async Task Test_WebApi_CreationPolicy_InsertOnStartReplaceOnEnd()
{
var insertEvs = new List <AuditEventWebApi>();
var updatedEvs = new List <AuditEventWebApi>();
Audit.Core.Configuration.Setup()
.UseDynamicProvider(_ => _.OnInsert(ev =>
{
insertEvs.Add(AuditEvent.FromJson <AuditEventWebApi>(ev.ToJson()));
})
.OnReplace((id, ev) => {
updatedEvs.Add(AuditEvent.FromJson <AuditEventWebApi>(ev.ToJson()));
}))
.WithCreationPolicy(EventCreationPolicy.InsertOnStartReplaceOnEnd);
var url = $"http://localhost:{_port}/api/My";
var client = new HttpClient();
var res = await client.GetAsync(url);
Assert.AreEqual(1, insertEvs.Count);
Assert.AreEqual(1, updatedEvs.Count);
Assert.IsNotNull(await res.Content.ReadAsStringAsync());
Assert.IsNull(insertEvs[0].Action.ResponseStatus);
Assert.AreEqual("OK", updatedEvs[0].Action.ResponseStatus);
}
public void Test_EF_CustomFields()
{
var guid = Guid.NewGuid().ToString().Substring(0, 6);
var evs = new List <AuditEvent>();
Audit.EntityFramework.Configuration.Setup()
.ForContext <BlogsEntities>(x => x.
IncludeEntityObjects(true));
Audit.Core.Configuration.Setup()
.AuditDisabled(false)
.UseDynamicProvider(x => x
.OnInsertAndReplace(ev =>
{
evs.Add(ev);
}))
.WithCreationPolicy(EventCreationPolicy.InsertOnEnd);
Audit.Core.Configuration.AddOnCreatedAction(scope =>
{
var efEvent = scope.GetEntityFrameworkEvent();
efEvent.CustomFields["Additional Field On event"] = new { x = 1, y = "one" };
efEvent.Entries[0].CustomFields["Additional Field On entry"] = new { x = 2, y = "two" };
});
using (var ctx = new BlogsEntities())
{
var blog = new Blog()
{
Title = guid
};
ctx.Blogs.Add(blog);
ctx.SaveChanges();
}
var ev2 = AuditEvent.FromJson <AuditEventEntityFramework>(evs[0].ToJson());
var sub1 = EntityFrameworkEvent.FromJson(evs[0].GetEntityFrameworkEvent().ToJson());
var sub2 = EventEntry.FromJson(evs[0].GetEntityFrameworkEvent().Entries[0].ToJson());
var settings = new JsonSerializerSettings()
{
ReferenceLoopHandling = ReferenceLoopHandling.Ignore, NullValueHandling = NullValueHandling.Ignore
};
Assert.AreEqual(JsonConvert.SerializeObject(evs[0].GetEntityFrameworkEvent(), settings), JsonConvert.SerializeObject(sub1, settings));
Assert.AreEqual(1, evs.Count);
Assert.AreEqual(evs[0].GetEntityFrameworkEvent().Entries[0].PrimaryKey["Id"], evs[0].GetEntityFrameworkEvent().Entries[0].ColumnValues["Id"]);
Assert.AreEqual(guid, evs[0].GetEntityFrameworkEvent().Entries[0].ColumnValues["Title"]);
Assert.AreEqual("Blogs", evs[0].GetEntityFrameworkEvent().Entries[0].Table);
Assert.AreEqual("dbo", evs[0].GetEntityFrameworkEvent().Entries[0].Schema.ToLower());
Assert.AreEqual(1, (evs[0].GetEntityFrameworkEvent().CustomFields["Additional Field On event"] as dynamic).x);
Assert.AreEqual("two", (evs[0].GetEntityFrameworkEvent().Entries[0].CustomFields["Additional Field On entry"] as dynamic).y);
Assert.AreEqual("one", (evs[0].GetEntityFrameworkEvent().CustomFields["Additional Field On event"] as dynamic).y);
Assert.AreEqual(2, (evs[0].GetEntityFrameworkEvent().Entries[0].CustomFields["Additional Field On entry"] as dynamic).x);
Assert.IsNotNull(ev2.EntityFrameworkEvent.CustomFields["Additional Field On event"]);
Assert.IsNotNull(ev2.EntityFrameworkEvent.Entries[0].CustomFields["Additional Field On entry"]);
}
public T FromValue <T>(RedisValue value) where T : AuditEvent
{
if (Deserializer == null)
{
return(AuditEvent.FromJson <T>(value));
}
return(Deserializer.Invoke(value) as T);
}
private AuditEvent DeserializeEvent(byte[] data)
{
if (CustomDeserializer != null)
{
return(CustomDeserializer.Invoke(data));
}
return(AuditEvent.FromJson(Encoding.UTF8.GetString(data)));
}
public override T GetEvent <T>(object eventId)
{
var name = eventId.ToString();
var container = EnsureContainer(null);
var blob = container.GetBlockBlobReference(name);
var json = blob.DownloadTextAsync().Result;
return(AuditEvent.FromJson <T>(json));
}
public override async Task <T> GetEventAsync <T>(object eventId)
{
var name = eventId.ToString();
var container = await EnsureContainerAsync(null);
var blob = container.GetBlockBlobReference(name);
var json = await blob.DownloadTextAsync();
return(AuditEvent.FromJson <T>(json));
}
public void Test_AuditScopeCreation_WithExistingAuditEvent_WithCustomFields()
{
var evs_onScopeCreated = new List <AuditEvent>();
var evs_Provider = new List <AuditEvent>();
Audit.Core.Configuration.Setup()
.AuditDisabled(false)
.UseDynamicProvider(x => x
.OnInsertAndReplace(ev =>
{
evs_Provider.Add(AuditEvent.FromJson(ev.ToJson()));
}))
.WithCreationPolicy(EventCreationPolicy.InsertOnEnd)
.WithAction(_ => _.OnScopeCreated(scope =>
{
evs_onScopeCreated.Add(AuditEvent.FromJson(scope.Event.ToJson()));
}));
var auditEvent = new AuditEvent()
{
EventType = "test",
CustomFields = new Dictionary <string, object>()
{
{ "FromCustomField", 1 }
}
};
var options = new AuditScopeOptions()
{
AuditEvent = auditEvent,
ExtraFields = new { FromAnon = 2 }
};
using (var scope = AuditScope.Create(options))
{
scope.SetCustomField("FromScope", 3);
}
Assert.AreEqual(1, evs_onScopeCreated.Count);
Assert.AreEqual(2, evs_onScopeCreated[0].CustomFields.Count);
Assert.IsTrue(evs_onScopeCreated[0].CustomFields.ContainsKey("FromCustomField"));
Assert.IsTrue(evs_onScopeCreated[0].CustomFields.ContainsKey("FromAnon"));
Assert.AreEqual(1, evs_onScopeCreated[0].CustomFields["FromCustomField"]);
Assert.AreEqual(2, evs_onScopeCreated[0].CustomFields["FromAnon"]);
Assert.AreEqual(1, evs_Provider.Count);
Assert.AreEqual(3, evs_Provider[0].CustomFields.Count);
Assert.IsTrue(evs_Provider[0].CustomFields.ContainsKey("FromCustomField"));
Assert.IsTrue(evs_Provider[0].CustomFields.ContainsKey("FromAnon"));
Assert.IsTrue(evs_Provider[0].CustomFields.ContainsKey("FromScope"));
Assert.AreEqual(1, evs_Provider[0].CustomFields["FromCustomField"]);
Assert.AreEqual(2, evs_Provider[0].CustomFields["FromAnon"]);
Assert.AreEqual(3, evs_Provider[0].CustomFields["FromScope"]);
}
public void Test_ProxiedLazyLoading()
{
var guid = Guid.NewGuid().ToString().Substring(0, 6);
var evs = new List <AuditEvent>();
Audit.EntityFramework.Configuration.Setup()
.ForContext <BlogsContext>(x => x.
IncludeEntityObjects(true))
.UseOptIn();
Audit.Core.Configuration.Setup()
.AuditDisabled(false)
.UseDynamicProvider(x => x
.OnInsertAndReplace(ev =>
{
evs.Add(ev);
}))
.WithCreationPolicy(EventCreationPolicy.InsertOnEnd);
Audit.Core.Configuration.AddOnCreatedAction(scope =>
{
var efEvent = scope.GetEntityFrameworkEvent();
efEvent.CustomFields["Additional Field On event"] = new { x = 1, y = "one" };
efEvent.Entries[0].CustomFields["Additional Field On entry"] = new { x = 2, y = "two" };
});
AuditEventEntityFramework ev2;
using (var ctx = new BlogsContext())
{
var blog = ctx.Blogs.FirstOrDefault();
blog.Title = guid;
ctx.SaveChanges();
ev2 = AuditEvent.FromJson <AuditEventEntityFramework>(evs[0].ToJson());
}
Assert.AreEqual(1, evs.Count);
Assert.IsTrue(evs[0].GetEntityFrameworkEvent().Entries[0].Entity.GetType().FullName.StartsWith("Castle.Proxies."));
Assert.AreEqual(evs[0].GetEntityFrameworkEvent().Entries[0].PrimaryKey["Id"], evs[0].GetEntityFrameworkEvent().Entries[0].ColumnValues["Id"]);
Assert.AreEqual(guid, evs[0].GetEntityFrameworkEvent().Entries[0].ColumnValues["Title"]);
Assert.AreEqual("Blogs", evs[0].GetEntityFrameworkEvent().Entries[0].Table);
Assert.AreEqual("dbo", evs[0].GetEntityFrameworkEvent().Entries[0].Schema.ToLower());
Assert.AreEqual(1, (evs[0].GetEntityFrameworkEvent().CustomFields["Additional Field On event"] as dynamic).x);
Assert.AreEqual("two", (evs[0].GetEntityFrameworkEvent().Entries[0].CustomFields["Additional Field On entry"] as dynamic).y);
Assert.AreEqual("one", (evs[0].GetEntityFrameworkEvent().CustomFields["Additional Field On event"] as dynamic).y);
Assert.AreEqual(2, (evs[0].GetEntityFrameworkEvent().Entries[0].CustomFields["Additional Field On entry"] as dynamic).x);
Assert.IsNotNull(ev2.EntityFrameworkEvent.CustomFields["Additional Field On event"]);
Assert.IsNotNull(ev2.EntityFrameworkEvent.Entries[0].CustomFields["Additional Field On entry"]);
}
/// <summary>
/// Gets an audit event from its primary key
/// </summary>
/// <typeparam name="T">The audit event type</typeparam>
/// <param name="hashKey">The primary key Hash portion</param>
/// <param name="rangeKey">The primary key Range portion, if any. Otherwise NULL.</param>
public T GetEvent <T>(Primitive hashKey, Primitive rangeKey) where T : AuditEvent
{
var table = GetTable(null);
Document doc;
if (rangeKey == null)
{
doc = table.GetItemAsync(hashKey).GetAwaiter().GetResult();
}
else
{
doc = table.GetItemAsync(hashKey, rangeKey).GetAwaiter().GetResult();
}
return(AuditEvent.FromJson <T>(doc.ToJson()));
}
/// <summary>
/// Gets an audit event from its primary key
/// </summary>
/// <typeparam name="T">The audit event type</typeparam>
/// <param name="hashKey">The primary key Hash portion</param>
/// <param name="rangeKey">The primary key Range portion, if any. Otherwise NULL.</param>
public async Task <T> GetEventAsync <T>(Primitive hashKey, Primitive rangeKey) where T : AuditEvent
{
var table = GetTable(null);
Document doc;
if (rangeKey == null)
{
doc = await table.GetItemAsync(hashKey);
}
else
{
doc = await table.GetItemAsync(hashKey, rangeKey);
}
return(AuditEvent.FromJson <T>(doc.ToJson()));
}
public async Task Test_EF_CustomFields_OnScopeCreated()
{
var evs = new List <AuditEventEntityFramework>();
Audit.EntityFramework.Configuration.Setup()
.ForContext <BlogsContext>(x => x
.IncludeEntityObjects(false));
Audit.Core.Configuration.Setup()
.AuditDisabled(false)
.UseDynamicProvider(x => x
.OnInsertAndReplace(ev =>
{
// Do nothing, will include the events on OnScopeCreated
}))
.WithCreationPolicy(EventCreationPolicy.InsertOnEnd)
.WithAction(_ => _.OnScopeCreated(scope =>
{
evs.Add(AuditEvent.FromJson <AuditEventEntityFramework>(scope.Event.ToJson()));
}));
var options = new DbContextOptionsBuilder <BlogsMemoryContext>()
.UseInMemoryDatabase(databaseName: "database_test")
.Options;
var id = Rnd.Next();
using (var ctx = new BlogsMemoryContext(options))
{
var user = new User()
{
Id = id,
Name = "fede",
Password = "******",
Token = "Test123"
};
ctx.Users.Add(user);
ctx.AddAuditCustomField("TestCustomField", 1L);
await ctx.SaveChangesAsync();
ctx.Users.Remove(user);
ctx.AddAuditCustomField("TestCustomField", 2L);
await ctx.SaveChangesAsync();
}
Assert.AreEqual(2, evs.Count);
Assert.IsTrue(evs[0].CustomFields.ContainsKey("TestCustomField"));
Assert.AreEqual(1L, evs[0].CustomFields["TestCustomField"]);
Assert.AreEqual(2L, evs[1].CustomFields["TestCustomField"]);
}
public override T GetEvent <T>(object eventId)
{
using (var cnn = new NpgsqlConnection(_connectionString))
{
var cmd = GetSelectCommand(cnn, eventId);
using (var reader = cmd.ExecuteReader())
{
if (reader.HasRows)
{
reader.Read();
var json = reader.GetString(0);
return(AuditEvent.FromJson <T>(json));
}
}
}
return(null);
}
public async Task Test_SaveChangesInterceptor_HappyPathAsync()
{
var inserted = new List <AuditEventEntityFramework>();
var replaced = new List <AuditEventEntityFramework>();
Audit.Core.Configuration.Setup()
.UseDynamicProvider(_ => _
.OnInsert(ev => inserted.Add(AuditEvent.FromJson <AuditEventEntityFramework>(ev.ToJson())))
.OnReplace((id, ev) => replaced.Add(AuditEvent.FromJson <AuditEventEntityFramework>(ev.ToJson()))));
Audit.EntityFramework.Configuration.Setup()
.ForContext <InterceptContext>(_ => _
.AuditEventType("{context}**")
.ForEntity <InterceptContext.Department>(dc => dc.Override(d => d.Comments, "override"))
.IncludeEntityObjects(true));
var guid = Guid.NewGuid().ToString();
var dept = new InterceptContext.Department()
{
Name = guid, Comments = "test"
};
using (var ctx = new InterceptContext(new DbContextOptionsBuilder().AddInterceptors(new AuditSaveChangesInterceptor()).Options))
{
await ctx.Database.EnsureDeletedAsync();
await ctx.Database.EnsureCreatedAsync();
await ctx.Departments.AddAsync(dept);
await ctx.SaveChangesAsync();
}
Assert.AreEqual(1, inserted.Count);
Assert.AreEqual(0, replaced.Count);
Assert.AreEqual("InterceptContext**", inserted[0].EventType);
Assert.AreEqual(true, inserted[0].EntityFrameworkEvent.Success);
Assert.AreEqual(1, inserted[0].EntityFrameworkEvent.Entries.Count);
Assert.IsTrue(inserted[0].EntityFrameworkEvent.Entries[0].Entity.ToString().Contains(guid));
Assert.AreEqual("Insert", inserted[0].EntityFrameworkEvent.Entries[0].Action);
Assert.AreEqual(3, inserted[0].EntityFrameworkEvent.Entries[0].ColumnValues.Count);
Assert.AreEqual(guid, inserted[0].EntityFrameworkEvent.Entries[0].ColumnValues["Name"].ToString());
Assert.AreEqual("override", inserted[0].EntityFrameworkEvent.Entries[0].ColumnValues["Comments"].ToString());
}
public override T GetEvent <T>(object eventId)
{
var idParam = new MySqlParameter("@id", eventId);
using (var cnn = new MySqlConnection(_connectionString))
{
var cmd = GetSelectCommand(cnn, idParam);
using (var reader = cmd.ExecuteReader())
{
if (reader.HasRows)
{
reader.Read();
var json = reader.GetFieldValue <string>(0);
return(AuditEvent.FromJson <T>(json));
}
}
}
return(null);
}
public override async Task <T> GetEventAsync <T>(object eventId)
{
using (var ctx = new AuditContext(ConnectionStringBuilder?.Invoke(null)))
{
var cmdText = GetSelectCommandText(null);
#if NET45
var result = ctx.Database.SqlQuery <string>(cmdText, new SqlParameter("eventId", eventId));
var json = await result.FirstOrDefaultAsync();
#elif NETSTANDARD1_3 || NETSTANDARD2_0
var result = ctx.FakeIdSet.FromSql(cmdText, new SqlParameter("eventId", eventId));
var json = (await result.FirstOrDefaultAsync())?.Id;
#endif
if (json != null)
{
return(AuditEvent.FromJson <T>(json));
}
}
return(null);
}
private async Task <T> GetFromQldb <T>(object eventId) where T : AuditEvent
{
var driver = QldbDriver.Value;
var(insertDocumentId, tableName) = (ValueTuple <string, string>)eventId;
IIonValue selectedEvent = null;
await driver.Execute(async trx =>
{
selectedEvent = await(await trx.Execute(
$@"SELECT e.*
FROM {tableName} AS e BY eid
WHERE eid = ?",
new ValueFactory().NewString(insertDocumentId))).FirstAsync();
});
var selectedAuditEvent = AuditEvent.FromJson <T>(selectedEvent.ToPrettyString());
return(selectedAuditEvent);
}
public async Task Test_DbCommandInterceptor_FailedAsync()
{
var inserted = new List <AuditEventCommandEntityFramework>();
var replaced = new List <AuditEventCommandEntityFramework>();
Audit.Core.Configuration.Setup()
.UseDynamicProvider(_ => _
.OnInsert(ev => inserted.Add(AuditEvent.FromJson <AuditEventCommandEntityFramework>(ev.ToJson())))
.OnReplace((id, ev) => replaced.Add(AuditEvent.FromJson <AuditEventCommandEntityFramework>(ev.ToJson()))))
.WithCreationPolicy(EventCreationPolicy.InsertOnEnd);
Audit.EntityFramework.Configuration.Setup()
.ForContext <DbCommandInterceptContext>(_ => _
.AuditEventType("{context}**")
.IncludeEntityObjects(true));
using (var ctx = new DbCommandInterceptContext(new DbContextOptionsBuilder().AddInterceptors(new AuditCommandInterceptor()).Options))
{
try
{
var result = await ctx.Database.ExecuteSqlRawAsync("SELECT 1/0");
}
catch (Exception ex)
{
var e = ex;
}
}
Assert.AreEqual(1, inserted.Count);
Assert.AreEqual(0, replaced.Count);
Assert.AreEqual(DbCommandMethod.ExecuteNonQuery.ToString(), inserted[0].EventType);
Assert.AreEqual(DbCommandMethod.ExecuteNonQuery, inserted[0].CommandEvent.Method);
Assert.IsTrue(inserted[0].CommandEvent.CommandText.Contains("SELECT 1/0"));
Assert.AreEqual(CommandType.Text, inserted[0].CommandEvent.CommandType);
Assert.IsNotNull(inserted[0].CommandEvent.ConnectionId);
Assert.IsNotNull(inserted[0].CommandEvent.ErrorMessage);
Assert.IsTrue(inserted[0].CommandEvent.ErrorMessage.Contains("Divide by zero"));
Assert.IsTrue(inserted[0].CommandEvent.IsAsync);
Assert.IsNull(inserted[0].CommandEvent.Result);
Assert.IsFalse(inserted[0].CommandEvent.Success);
Assert.AreEqual("DbCommandIntercept", inserted[0].CommandEvent.Database);
}
public async Task Test_AsyncCustomAction_Fluent_Async()
{
var evs = new List <AuditEvent>();
bool saved = false;
Audit.Core.Configuration.Setup()
.UseDynamicAsyncProvider(_ => _.OnInsert(async ev =>
{
evs.Add(AuditEvent.FromJson(ev.ToJson()));
await Task.Delay(0);
}))
.WithCreationPolicy(EventCreationPolicy.Manual)
.ResetActions()
.WithAction(action => action
.OnEventSaved(async scope =>
{
await Task.Delay(500);
saved = true;
}))
.WithAction(action => action
.OnEventSaving(async scope =>
{
await Task.Delay(500);
scope.Comment("OnEventSaving");
}))
.WithAction(action => action
.OnScopeCreated(async scope =>
{
await Task.Delay(500);
scope.Comment("OnScopeCreated");
}));
using (var scope = await AuditScope.CreateAsync("test", null))
{
await scope.SaveAsync();
}
Assert.AreEqual(1, evs.Count);
Assert.IsTrue(evs[0].Comments.Contains("OnScopeCreated"));
Assert.IsTrue(evs[0].Comments.Contains("OnEventSaving"));
Assert.IsTrue(saved);
}
private T GetFromQldb <T>(object eventId) where T : AuditEvent
{
var driver = QldbDriver.Value;
var(insertDocumentId, tableName) = (ValueTuple <string, string>)eventId;
IResult selectResult = null;
driver.Execute(trx =>
{
selectResult = trx.Execute(
$@"SELECT e.*
FROM {tableName} AS e BY eid
WHERE eid = ?",
new ValueFactory().NewString(insertDocumentId));
});
var selectedEvent = selectResult.First();
var selectedAuditEvent = AuditEvent.FromJson <T>(selectedEvent.ToPrettyString());
return(selectedAuditEvent);
}
public async Task Test_WebApi_CreationPolicy_Manual()
{
var insertEvs = new List <AuditEventWebApi>();
var updatedEvs = new List <AuditEventWebApi>();
Audit.Core.Configuration.Setup()
.UseDynamicProvider(_ => _.OnInsert(ev =>
{
insertEvs.Add(AuditEvent.FromJson <AuditEventWebApi>(ev.ToJson()));
})
.OnReplace((id, ev) => {
updatedEvs.Add(AuditEvent.FromJson <AuditEventWebApi>(ev.ToJson()));
}))
.WithCreationPolicy(EventCreationPolicy.Manual);
var url = $"http://localhost:{_port}/api/My";
var client = new HttpClient();
var res = await client.GetAsync(url);
Assert.AreEqual(0, insertEvs.Count);
Assert.AreEqual(0, updatedEvs.Count);
}
public void Test_AsyncCustomAction()
{
var evs = new List <AuditEvent>();
Audit.Core.Configuration.Setup()
.UseDynamicProvider(_ => _.OnInsert(ev =>
{
evs.Add(AuditEvent.FromJson(ev.ToJson()));
}))
.WithCreationPolicy(EventCreationPolicy.InsertOnEnd);
bool saved = false;
Audit.Core.Configuration.AddCustomAction(ActionType.OnScopeCreated, async scope =>
{
await Task.Delay(500);
scope.Comment("OnScopeCreated");
});
Audit.Core.Configuration.AddCustomAction(ActionType.OnEventSaving, async scope =>
{
await Task.Delay(500);
scope.Comment("OnEventSaving");
});
Audit.Core.Configuration.AddCustomAction(ActionType.OnEventSaved, async scope =>
{
await Task.Delay(500);
saved = true;
});
using (var scope = AuditScope.Create("test", null))
{
}
Assert.AreEqual(1, evs.Count);
Assert.IsTrue(evs[0].Comments.Contains("OnScopeCreated"));
Assert.IsTrue(evs[0].Comments.Contains("OnEventSaving"));
Assert.IsTrue(saved);
}
public void Test_AuditScopeCreation_WithExistingAuditEvent_WithEventType()
{
var evs = new List <AuditEvent>();
Audit.Core.Configuration.Setup()
.AuditDisabled(false)
.UseDynamicProvider(x => x
.OnInsertAndReplace(ev =>
{
evs.Add(AuditEvent.FromJson(ev.ToJson()));
}))
.WithCreationPolicy(EventCreationPolicy.InsertOnEnd);
var auditEvent = new AuditEvent()
{
EventType = "test"
};
var options = new AuditScopeOptions()
{
EventType = null, // NULL means do not override eventtype
AuditEvent = auditEvent
};
// scope with pre-assigned event type
using (var scope = AuditScope.Create(options))
{
}
// scope with event type to override
options.EventType = "override";
using (var scope = AuditScope.Create(options))
{
}
Assert.AreEqual(2, evs.Count);
Assert.AreEqual("test", evs[0].EventType);
Assert.AreEqual("override", evs[1].EventType);
}
public void Test_WcfClient_Success()
{
var inserted = new List <AuditEvent>();
var replaced = new List <AuditEvent>();
var idsReplaced = new List <object>();
Audit.Core.Configuration.Setup()
.UseDynamicProvider(_ => _
.OnInsert(ev => inserted.Add(AuditEvent.FromJson(ev.ToJson())))
.OnReplace((id, ev) => { replaced.Add(AuditEvent.FromJson(ev.ToJson())); idsReplaced.Add(id); }))
.WithCreationPolicy(EventCreationPolicy.InsertOnStartReplaceOnEnd);
var channel = GetServiceProxy(out ICatalogService svc);
using (var scope = new OperationContextScope(channel))
{
OperationContext.Current.OutgoingMessageProperties[HttpRequestMessageProperty.Name] = new HttpRequestMessageProperty()
{
Headers =
{
{ "CustomHeader", Environment.UserName }
}
};
try
{
var r = svc.InsertProduct("001", new Product()
{
Name = "test name", Price = 12.34M
});
}
catch (FaultException ex)
{
Assert.IsTrue(ex.Message.Contains("internal error"));
}
}
Assert.AreEqual(1, inserted.Count);
Assert.AreEqual(1, replaced.Count);
Assert.AreEqual(1, idsReplaced.Count);
var actionInserted = inserted[0].GetWcfClientAction();
var actionReplaced = replaced[0].GetWcfClientAction();
Assert.IsNotNull(actionInserted);
Assert.IsNotNull(actionReplaced);
Assert.IsTrue(actionInserted.Action.Contains("InsertProduct"));
Assert.IsTrue(actionReplaced.Action.Contains("InsertProduct"));
Assert.IsTrue(inserted[0].EventType.Contains("Catalog:") && inserted[0].EventType.Contains("InsertProduct"));
Assert.IsTrue(replaced[0].EventType.Contains("Catalog:") && inserted[0].EventType.Contains("InsertProduct"));
Assert.IsNull(inserted[0].EndDate);
Assert.IsNotNull(replaced[0].EndDate);
Assert.IsTrue(actionInserted.RequestBody.Contains("test name") && actionInserted.RequestBody.Contains("001"));
Assert.IsTrue(actionReplaced.RequestBody.Contains("test name") && actionReplaced.RequestBody.Contains("001"));
Assert.IsNull(actionInserted.ResponseBody);
Assert.IsTrue(actionReplaced.ResponseBody.Contains("InsertProductResponse"));
Assert.IsNull(actionInserted.ResponseHeaders);
Assert.IsTrue(actionReplaced.ResponseHeaders.Count > 0);
Assert.IsNull(actionInserted.ResponseStatuscode);
Assert.AreEqual(200, (int)actionReplaced.ResponseStatuscode);
Assert.IsTrue(actionInserted.RequestHeaders.ContainsKey("CustomHeader"));
Assert.IsTrue(actionReplaced.RequestHeaders.ContainsKey("CustomHeader"));
Assert.AreEqual(Environment.UserName, actionInserted.RequestHeaders["CustomHeader"]);
Assert.AreEqual(Environment.UserName, actionReplaced.RequestHeaders["CustomHeader"]);
Assert.AreEqual("POST", actionInserted.HttpMethod);
Assert.AreEqual("POST", actionReplaced.HttpMethod);
Assert.IsFalse(actionInserted.IsFault);
Assert.IsFalse(actionReplaced.IsFault);
}
