public void Test_AmazonQLDB_HappyPath()
{
var ins = new List <AuditEvent>();
var repl = new List <AuditEvent>();
var qldb = GetAmazonQLDBDataProvider(ins, repl);
Configuration.Setup()
.UseCustomProvider(qldb)
.WithCreationPolicy(EventCreationPolicy.InsertOnStartReplaceOnEnd)
.ResetActions();
var sb = "init";
using (var scope = new AuditScopeFactory().Create("test_table", () => sb, new { MyCustomField = "value" }, null, null))
{
sb += "-end";
}
Assert.AreEqual(1, ins.Count);
Assert.AreEqual(1, repl.Count);
Assert.AreEqual("init", ins[0].Target.Old);
Assert.AreEqual(null, ins[0].Target.New);
Assert.AreEqual("init", repl[0].Target.Old);
Assert.AreEqual("init-end", repl[0].Target.New);
}
public void Test_Elasticsearch_HappyPath()
{
var ins = new List <Core.AuditEvent>();
var repl = new List <Core.AuditEvent>();
var ela = GetElasticsearchDataProvider(ins, repl);
var guids = new List <string>();
ela.IndexBuilder = ev => "auditevent2";
ela.IdBuilder = ev => { var g = Guid.NewGuid().ToString().Replace("-", "/"); guids.Add(g); return(g); };
Audit.Core.Configuration.Setup()
.UseCustomProvider(ela)
.WithCreationPolicy(Core.EventCreationPolicy.InsertOnStartReplaceOnEnd)
.ResetActions();
var sb = "init";
using (var scope = new AuditScopeFactory().Create("eventType", () => sb, new { MyCustomField = "value" }, null, null))
{
sb += "-end";
}
Assert.AreEqual(1, guids.Count);
Assert.AreEqual(1, ins.Count);
Assert.AreEqual(1, repl.Count);
Assert.AreEqual("\"init\"", ins[0].Target.Old);
Assert.AreEqual(null, ins[0].Target.New);
Assert.AreEqual("\"init\"", repl[0].Target.Old);
Assert.AreEqual("\"init-end\"", repl[0].Target.New);
}
public void Test_AuditScope_SetTargetGetter()
{
var evs = new List <AuditEvent>();
Audit.Core.Configuration.Setup()
.Use(x => x
.OnInsertAndReplace(ev =>
{
evs.Add(ev);
}))
.WithCreationPolicy(EventCreationPolicy.InsertOnEnd);
var obj = new SomeClass()
{
Id = 1, Name = "Test"
};
using (var scope = new AuditScopeFactory().Create("Test", () => new { ShouldNotUseThisObject = true }))
{
scope.SetTargetGetter(() => obj);
obj.Id = 2;
obj.Name = "NewTest";
}
obj.Id = 3;
obj.Name = "X";
Assert.AreEqual(1, evs.Count);
Assert.AreEqual("SomeClass", evs[0].Target.Type);
Assert.AreEqual(1, (evs[0].Target.Old as JObject).ToObject <SomeClass>().Id);
Assert.AreEqual("Test", (evs[0].Target.Old as JObject).ToObject <SomeClass>().Name);
Assert.AreEqual(2, (evs[0].Target.New as JObject).ToObject <SomeClass>().Id);
Assert.AreEqual("NewTest", (evs[0].Target.New as JObject).ToObject <SomeClass>().Name);
}
public void Test_FileLog_HappyPath()
{
var dir = Path.Combine(Path.GetTempPath(), "Test_FileLog_HappyPath");
if (Directory.Exists(dir))
{
Directory.Delete(dir, true);
}
Audit.Core.Configuration.Setup()
.UseFileLogProvider(x => x
.Directory(dir)
.FilenameBuilder(_ => $"{_.EventType}-{_.CustomFields["X"]}.json"))
.WithCreationPolicy(EventCreationPolicy.InsertOnStartReplaceOnEnd);
var target = "start";
using (var scope = new AuditScopeFactory().Create("evt", () => target, new { X = 1 }, null, null))
{
target = "end";
}
var fileFromProvider = (Audit.Core.Configuration.DataProvider as FileDataProvider).GetEvent($@"{dir}\evt-1.json");
var ev = JsonConvert.DeserializeObject <AuditEvent>(File.ReadAllText(Path.Combine(dir, "evt-1.json")));
var fileCount = Directory.EnumerateFiles(dir).Count();
Directory.Delete(dir, true);
Assert.AreEqual(1, fileCount);
Assert.AreEqual(JsonConvert.SerializeObject(ev), JsonConvert.SerializeObject(fileFromProvider));
Assert.AreEqual("evt", ev.EventType);
Assert.AreEqual("start", ev.Target.Old);
Assert.AreEqual("end", ev.Target.New);
Assert.AreEqual("1", ev.CustomFields["X"].ToString());
}
public void TestMongoDateSerialization()
{
Audit.Core.Configuration.Setup()
.UseMongoDB(config => config
.ConnectionString("mongodb://localhost:27017")
.Database("Audit")
.Collection("Event"))
.WithCreationPolicy(EventCreationPolicy.InsertOnEnd)
.ResetActions();
object evId = null;
Audit.Core.Configuration.AddCustomAction(ActionType.OnEventSaved, s =>
{
if (evId != null)
{
Assert.Fail("evId should be null");
}
evId = s.EventId;
});
var now = DateTime.UtcNow;
using (var s = new AuditScopeFactory().Create("test", null, new { someDate = now }, null, null))
{
}
Audit.Core.Configuration.ResetCustomActions();
var dp = Audit.Core.Configuration.DataProvider as MongoDataProvider;
var evt = dp.GetEvent(evId);
Assert.AreEqual(now.ToString("yyyyMMddHHmmss"), (evt.CustomFields["someDate"] as DateTime?).Value.ToString("yyyyMMddHHmmss"));
}
public void Test_UdpDataProvider_BasicTest(string ip, int port, bool multicast)
{
stop = false;
events.Clear();
var p = new Udp.Providers.UdpDataProvider();
p.RemoteAddress = UdpProviderConfigurator.GetIPAddress(ip);
p.RemotePort = port;
var cts = new CancellationTokenSource();
var re = new ManualResetEvent(false);
var listener = Task.Factory.StartNew(() => { Listen(re, ip, port, multicast); }, cts.Token);
re.WaitOne();
Task.Delay(1000).Wait();
using (var scope = new AuditScopeFactory().Create("Test_UdpDataProvider_BasicTest", null, EventCreationPolicy.InsertOnStartReplaceOnEnd, p))
{
Task.Delay(100).Wait();
}
Task.Delay(2000).Wait();
stop = true;
cts.Cancel();
Task.Delay(2000).Wait();
Assert.AreEqual(2, events.Count);
Assert.AreEqual("Test_UdpDataProvider_BasicTest", events[0].EventType);
Assert.AreEqual("Test_UdpDataProvider_BasicTest", events[1].EventType);
Assert.NotNull(events[0].CustomFields["UdpEventId"]);
Assert.AreEqual(events[0].CustomFields["UdpEventId"], events[1].CustomFields["UdpEventId"]);
}
public void Test_NLog_InsertOnStartInsertOnEnd()
{
Audit.Core.Configuration.Setup()
.UseNLog(_ => _
.LogLevel(ev => (LogLevel)ev.CustomFields["LogLevel"])
.Logger(ev => LogManager.GetLogger(typeof(NLogTests).ToString())));
_adapter.Logs.Clear();
using (var s = new AuditScopeFactory().Create(new AuditScopeOptions()
{
CreationPolicy = EventCreationPolicy.InsertOnStartInsertOnEnd,
EventType = nameof(Test_NLog_InsertOnStartInsertOnEnd),
ExtraFields = new
{
LogLevel = LogLevel.Debug
}
}))
{
s.Event.CustomFields["LogLevel"] = LogLevel.Error;
}
var events = _adapter.Logs.Select(l => new NLogObject(l)).ToArray();
Assert.AreEqual(2, events.Length);
Assert.AreEqual(LogLevel.Debug, events[0].Level);
Assert.AreEqual(LogLevel.Error, events[1].Level);
Assert.AreEqual(nameof(Test_NLog_InsertOnStartInsertOnEnd), JsonAdapter.Deserialize <AuditEvent>(events[0].MessageObject).EventType);
Assert.AreEqual(nameof(Test_NLog_InsertOnStartInsertOnEnd), JsonAdapter.Deserialize <AuditEvent>(events[1].MessageObject).EventType);
Assert.AreNotEqual(JsonAdapter.Deserialize <AuditEvent>(events[0].MessageObject).CustomFields["EventId"], JsonAdapter.Deserialize <AuditEvent>(events[1].MessageObject).CustomFields["EventId"]);
}
public void Test_UdpDataProvider_BigPacket(string ip, int port, bool multicast)
{
stop = false;
events.Clear();
var p = new Udp.Providers.UdpDataProvider();
p.RemoteAddress = UdpProviderConfigurator.GetIPAddress(ip);
p.RemotePort = port;
var cts = new CancellationTokenSource();
var re = new ManualResetEvent(false);
var listener = Task.Factory.StartNew(() => { Listen(re, ip, port, multicast); }, cts.Token);
re.WaitOne();
Task.Delay(1000).Wait();
var target = Enumerable.Range(1, 10000).Select(_ => (byte)255).ToArray();
using (var scope = new AuditScopeFactory().Create("Test_UdpDataProvider_BigPacket", () => target, EventCreationPolicy.InsertOnEnd, p))
{
}
Task.Delay(1000).Wait();
Assert.AreEqual(1, events.Count);
}
public void Test_ScopeSaveMode_Manual()
{
var modes = new List <SaveMode>();
Audit.Core.Configuration.Setup()
.UseDynamicProvider(x => x
.OnInsert(ev => { })
.OnReplace((id, ev) => { }))
.WithCreationPolicy(EventCreationPolicy.Manual)
.WithAction(a => a
.OnEventSaving(scope =>
{
modes.Add(scope.SaveMode);
}));
using (var scope = new AuditScopeFactory().Create(new AuditScopeOptions()
{
}))
{
scope.Save();
}
Assert.AreEqual(1, modes.Count);
Assert.AreEqual(SaveMode.Manual, modes[0]);
}
public void Test_log4net_InsertOnStartInsertOnEnd()
{
Audit.Core.Configuration.Setup()
.UseLog4net(_ => _
.LogLevel(ev => (LogLevel)ev.CustomFields["LogLevel"])
.Logger(ev => ev.CustomFields["Logger"] as ILog));
_adapter.Clear();
using (var s = new AuditScopeFactory().Create(new AuditScopeOptions()
{
CreationPolicy = EventCreationPolicy.InsertOnStartInsertOnEnd,
EventType = "Test_log4net_InsertOnStartInsertOnEnd",
ExtraFields = new
{
Logger = LogManager.GetLogger(typeof(Log4netTests)),
LogLevel = LogLevel.Debug
}
}))
{
s.Event.CustomFields["LogLevel"] = LogLevel.Error;
}
var events = _adapter.PopAllEvents();
Assert.AreEqual(2, events.Length);
Assert.AreEqual(Level.Debug, events[0].Level);
Assert.AreEqual(Level.Error, events[1].Level);
Assert.AreEqual("Test_log4net_InsertOnStartInsertOnEnd", JsonAdapter.Deserialize <AuditEvent>(events[0].MessageObject.ToString()).EventType);
Assert.AreEqual("Test_log4net_InsertOnStartInsertOnEnd", JsonAdapter.Deserialize <AuditEvent>(events[1].MessageObject.ToString()).EventType);
Assert.AreNotEqual(JsonAdapter.Deserialize <AuditEvent>(events[0].MessageObject.ToString()).CustomFields["EventId"].ToString(), JsonAdapter.Deserialize <AuditEvent>(events[1].MessageObject.ToString()).CustomFields["EventId"].ToString());
}
public void Test_CustomAction_OnCreating()
{
var provider = new Mock <AuditDataProvider>();
provider.Setup(p => p.Serialize(It.IsAny <string>())).CallBase();
var eventType = "event type 1";
var target = "test";
Core.Configuration.AddOnCreatedAction(scope =>
{
scope.SetCustomField("custom field", "test");
if (scope.EventType == eventType)
{
scope.Discard();
}
});
Core.Configuration.AddOnSavingAction(scope =>
{
Assert.True(false, "This should not be executed");
});
AuditEvent ev;
using (var scope = new AuditScopeFactory().Create(eventType, () => target, EventCreationPolicy.InsertOnStartInsertOnEnd, provider.Object))
{
ev = scope.Event;
}
Core.Configuration.ResetCustomActions();
Assert.True(ev.CustomFields.ContainsKey("custom field"));
provider.Verify(p => p.InsertEvent(It.IsAny <AuditEvent>()), Times.Never);
provider.Verify(p => p.ReplaceEvent(It.IsAny <object>(), It.IsAny <AuditEvent>()), Times.Never);
}
public void Test_log4net_InsertOnStartReplaceOnEnd()
{
Audit.Core.Configuration.Setup()
.UseLog4net(_ => _
.LogLevel(LogLevel.Info));
_adapter.Clear();
using (var s = new AuditScopeFactory().Create(new AuditScopeOptions()
{
CreationPolicy = EventCreationPolicy.InsertOnStartReplaceOnEnd,
EventType = "Test_log4net_InsertOnStartReplaceOnEnd"
}))
{
}
var events = _adapter.PopAllEvents();
Assert.AreEqual(2, events.Length);
Assert.AreEqual("Test_log4net_InsertOnStartReplaceOnEnd", JsonAdapter.Deserialize <AuditEvent>(events[0].MessageObject.ToString()).EventType);
Assert.AreEqual("Test_log4net_InsertOnStartReplaceOnEnd", JsonAdapter.Deserialize <AuditEvent>(events[1].MessageObject.ToString()).EventType);
var jsonAdapter = new JsonAdapter();
Assert.AreEqual(jsonAdapter.Deserialize <AuditEvent>(events[0].MessageObject.ToString()).CustomFields["EventId"].ToString(), jsonAdapter.Deserialize <AuditEvent>(events[1].MessageObject.ToString()).CustomFields["EventId"].ToString());
}
public void Test_CustomAction_OnSaving()
{
var provider = new Mock <AuditDataProvider>();
provider.Setup(p => p.Serialize(It.IsAny <string>())).CallBase();
//provider.Setup(p => p.InsertEvent(It.IsAny<AuditEvent>())).Returns((AuditEvent e) => e.Comments);
var eventType = "event type 1";
var target = "test";
var comment = "comment test";
Core.Configuration.AddCustomAction(ActionType.OnEventSaving, scope =>
{
scope.Comment(comment);
});
AuditEvent ev;
using (var scope = new AuditScopeFactory().Create(eventType, () => target, EventCreationPolicy.Manual, provider.Object))
{
ev = scope.Event;
scope.Save();
}
Core.Configuration.ResetCustomActions();
Assert.True(ev.Comments.Contains(comment));
provider.Verify(p => p.InsertEvent(It.IsAny <AuditEvent>()), Times.Once);
}
public void Test_CustomAction_OnCreating_Double()
{
var provider = new Mock <AuditDataProvider>();
provider.Setup(p => p.Serialize(It.IsAny <string>())).CallBase();
var eventType = "event type 1";
var target = "test";
var key1 = "key1";
var key2 = "key2";
Core.Configuration.AddCustomAction(ActionType.OnScopeCreated, scope =>
{
scope.SetCustomField(key1, "test");
});
Core.Configuration.AddCustomAction(ActionType.OnScopeCreated, scope =>
{
scope.Event.CustomFields.Remove(key1);
scope.SetCustomField(key2, "test");
});
AuditEvent ev;
using (var scope = new AuditScopeFactory().Create(eventType, () => target, EventCreationPolicy.Manual, provider.Object))
{
ev = scope.Event;
}
Core.Configuration.ResetCustomActions();
Assert.False(ev.CustomFields.ContainsKey(key1));
Assert.True(ev.CustomFields.ContainsKey(key2));
provider.Verify(p => p.InsertEvent(It.IsAny <AuditEvent>()), Times.Never);
provider.Verify(p => p.ReplaceEvent(It.IsAny <object>(), It.IsAny <AuditEvent>()), Times.Never);
}
public void Test_AuditScope_Factory_FluentApi()
{
var mb = typeof(UnitTest).GetTypeInfo().GetMethods().First();
var scope = new AuditScopeFactory().Create(_ => _
.EventType("event type")
.ExtraFields(new { f = 1 })
.CreationPolicy(EventCreationPolicy.Manual)
.AuditEvent(new AuditEventEntityFramework())
.DataProvider(new DynamicDataProvider())
.IsCreateAndSave(true)
.SkipExtraFrames(1)
.Target(() => 1)
.CallingMethod(mb));
Assert.AreEqual("event type", scope.EventType);
Assert.AreEqual("event type", scope.Event.EventType);
Assert.IsTrue(scope.Event.CustomFields.ContainsKey("f"));
Assert.AreEqual(EventCreationPolicy.Manual, scope.EventCreationPolicy);
Assert.AreEqual(typeof(AuditEventEntityFramework), scope.Event.GetType());
Assert.AreEqual(typeof(DynamicDataProvider), scope.DataProvider.GetType());
Assert.AreEqual(SaveMode.InsertOnStart, scope.SaveMode);
Assert.AreEqual("1", scope.Event.Target.Old.ToString());
Assert.IsTrue(scope.Event.Environment.CallingMethodName.Contains(mb.Name));
}
public void Test_Dispose()
{
var provider = new Mock <AuditDataProvider>();
using (var scope = new AuditScopeFactory().Create(null, null, EventCreationPolicy.InsertOnEnd, provider.Object))
{
}
provider.Verify(p => p.InsertEvent(It.IsAny <AuditEvent>()), Times.Exactly(1));
}
public void Test_ExtraFields()
{
Core.Configuration.DataProvider = new FileDataProvider();
var scope = new AuditScopeFactory().Create(new AuditScopeOptions("SomeEvent", null, new { @class = "class value", DATA = 123 }, null, EventCreationPolicy.Manual));
scope.Comment("test");
var ev = scope.Event;
scope.Discard();
Assert.AreEqual("123", ev.CustomFields["DATA"].ToString());
Assert.AreEqual("class value", ev.CustomFields["class"].ToString());
}
public void Test_EventCreationPolicy_InsertOnEnd()
{
var provider = new Mock <AuditDataProvider>();
Core.Configuration.DataProvider = provider.Object;
using (var scope = new AuditScopeFactory().Create("SomeEvent", () => "target", EventCreationPolicy.InsertOnEnd, null))
{
scope.Comment("test");
scope.Save(); // this should do nothing because of the creation policy (this is no more true, since v 4.6.2)
}
provider.Verify(p => p.ReplaceEvent(It.IsAny <object>(), It.IsAny <AuditEvent>()), Times.Never);
provider.Verify(p => p.InsertEvent(It.IsAny <AuditEvent>()), Times.Exactly(2));
}
public void Test_EventCreationPolicy_InsertOnStartInsertOnEnd()
{
var provider = new Mock <AuditDataProvider>();
provider.Setup(p => p.InsertEvent(It.IsAny <AuditEvent>())).Returns(() => Guid.NewGuid());
Core.Configuration.DataProvider = provider.Object;
using (var scope = new AuditScopeFactory().Create("SomeEvent", () => "target", EventCreationPolicy.InsertOnStartInsertOnEnd, null))
{
scope.Comment("test");
}
provider.Verify(p => p.ReplaceEvent(It.IsAny <object>(), It.IsAny <AuditEvent>()), Times.Never);
provider.Verify(p => p.InsertEvent(It.IsAny <AuditEvent>()), Times.Exactly(2));
}
public void Test_FluentConfig_EventLog()
{
Core.Configuration.Setup()
.UseEventLogProvider(config => config.LogName("LogName").SourcePath("SourcePath").MachineName("MachineName"))
.WithCreationPolicy(EventCreationPolicy.Manual);
var scope = new AuditScopeFactory().Create("test", null);
scope.Dispose();
Assert.AreEqual(typeof(EventLogDataProvider), Core.Configuration.DataProvider.GetType());
Assert.AreEqual("LogName", (Core.Configuration.DataProvider as EventLogDataProvider).LogName);
Assert.AreEqual("SourcePath", (Core.Configuration.DataProvider as EventLogDataProvider).SourcePath);
Assert.AreEqual("MachineName", (Core.Configuration.DataProvider as EventLogDataProvider).MachineName);
Assert.AreEqual(EventCreationPolicy.Manual, Core.Configuration.CreationPolicy);
}
public void TestStressDynamo()
{
int N = 32;
SetDynamoSettings();
var hashes = new HashSet <string>();
int count = 0;
Audit.Core.Configuration.AddCustomAction(ActionType.OnEventSaved, scope =>
{
count++;
hashes.Add((scope.EventId as object[])[0].ToString());
});
var rnd = new Random();
//Parallel random insert into event1, event2 and event3 containers
Parallel.ForEach(Enumerable.Range(1, N), i =>
{
var eventType = "AuditEvents";
var x = "start";
using (var s = new AuditScopeFactory().Create(eventType, () => x, EventCreationPolicy.InsertOnStartReplaceOnEnd, null))
{
x = "end";
}
});
Assert.AreEqual(N, hashes.Count);
Assert.AreEqual(N * 2, count);
// Assert events
int maxCheck = N / 4;
int check = 0;
foreach (var hash in hashes)
{
if (check++ > maxCheck)
{
break;
}
var ddp = (Configuration.DataProvider as DynamoDataProvider);
var ev = ddp.GetEvent <AuditEvent>((Primitive)hash, (Primitive)DateTime.Now.Year);
Assert.NotNull(ev);
Assert.AreEqual("AuditEvents", ev.EventType);
Assert.AreEqual(DateTime.Now.Year, ev.CustomFields["SortKey"]);
Assert.AreEqual(hash, ev.CustomFields["HashKey"]);
}
}
public void Test_UdpDataProvider_PacketOverflow(string ip, int port, bool multicast)
{
var p = new Udp.Providers.UdpDataProvider();
p.RemoteAddress = UdpProviderConfigurator.GetIPAddress(ip);
p.RemotePort = port;
var target = Enumerable.Range(1, 66000).Select(_ => (byte)255).ToArray();
Assert.Throws <SocketException>(() =>
{
using (var scope = new AuditScopeFactory().Create("Test_UdpDataProvider_BigPacket", () => target, EventCreationPolicy.InsertOnEnd, p))
{
}
});
}
public void TestInsert()
{
var ev = (AuditEvent)null;
CustomerOrder order = null;
using (var audit = new AuditScopeFactory().Create("Order:Create", () => new TestStruct()
{
Id = 123, Order = order
}))
{
ev = audit.Event;
order = DbCreateOrder();
audit.SetCustomField("ReferenceId", order.OrderId);
}
Assert.AreEqual(order.OrderId, ev.CustomFields["ReferenceId"]);
}
public void TestDelete()
{
IntegrationTests.CustomerOrder order = DbCreateOrder();
var ev = (AuditEvent)null;
var orderId = order.OrderId;
using (var audit = new AuditScopeFactory().Create("Order:Delete", () => new TestStruct()
{
Id = 123, Order = order
}, new { ReferenceId = order.OrderId }, null, null))
{
ev = audit.Event;
DbDeteleOrder(order.OrderId);
order = null;
}
Assert.AreEqual(orderId, ev.CustomFields["ReferenceId"]);
}
public async Task Test_ScopeActionsStress_Async()
{
int counter = 0;
int counter2 = 0;
int counter3 = 0;
int MAX = 200;
Audit.Core.Configuration.Setup()
.UseDynamicProvider(_ => _.OnInsert(ev =>
{
System.Threading.Interlocked.Increment(ref counter);
}))
.WithCreationPolicy(EventCreationPolicy.InsertOnEnd)
.WithAction(_ => _.OnEventSaving(ev =>
{
System.Threading.Interlocked.Increment(ref counter2);
}))
.WithAction(_ => _.OnScopeCreated(ev =>
{
System.Threading.Interlocked.Increment(ref counter3);
}));
var tasks = new List <Task>();
var factory = new AuditScopeFactory();
for (int i = 0; i < MAX; i++)
{
tasks.Add(Task.Factory.StartNew(async() =>
{
await factory.LogAsync("LoginSuccess", new { username = "******", id = i });
Audit.Core.Configuration.AddCustomAction(ActionType.OnEventSaving, ev =>
{
//do nothing, just bother
var d = ev.Event.Duration * 1234567;
});
await factory.CreateAsync(new AuditScopeOptions("LoginFailed", extraFields: new { username = "******", id = i * -1 }, isCreateAndSave: true));
}));
}
await Task.WhenAll(tasks.ToArray());
await Task.Delay(1000);
Assert.AreEqual(MAX * 2, counter);
Assert.AreEqual(MAX * 2, counter2);
Assert.AreEqual(MAX * 2, counter3);
}
public void Test_TwoScopes()
{
var provider = new Mock <AuditDataProvider>();
provider.Setup(p => p.InsertEvent(It.IsAny <AuditEvent>())).Returns(() => Guid.NewGuid());
Core.Configuration.DataProvider = provider.Object;
var scope1 = new AuditScopeFactory().Create(new AuditScopeOptions("SomeEvent1", null, new { @class = "class value1", DATA = 111 }, null, EventCreationPolicy.Manual));
scope1.Save();
var scope2 = new AuditScopeFactory().Create(new AuditScopeOptions("SomeEvent2", null, new { @class = "class value2", DATA = 222 }, null, EventCreationPolicy.Manual));
scope2.Save();
Assert.NotNull(scope1.EventId);
Assert.NotNull(scope2.EventId);
Assert.AreNotEqual(scope1.EventId, scope2.EventId);
provider.Verify(p => p.InsertEvent(It.IsAny <AuditEvent>()), Times.Exactly(2));
}
public void Test_FluentConfig_FileLog()
{
int x = 0;
Core.Configuration.Setup()
.UseFileLogProvider(config => config.Directory(@"C:\").FilenamePrefix("prefix"))
.WithCreationPolicy(EventCreationPolicy.Manual)
.WithAction(action => action.OnScopeCreated(s => x++));
var scope = new AuditScopeFactory().Create("test", null);
scope.Dispose();
Assert.AreEqual(typeof(FileDataProvider), Core.Configuration.DataProvider.GetType());
Assert.AreEqual("prefix", (Core.Configuration.DataProvider as FileDataProvider).FilenamePrefix);
Assert.AreEqual(@"C:\", (Core.Configuration.DataProvider as FileDataProvider).DirectoryPath);
Assert.AreEqual(EventCreationPolicy.Manual, Core.Configuration.CreationPolicy);
Assert.True(Core.Configuration.AuditScopeActions.ContainsKey(ActionType.OnScopeCreated));
Assert.AreEqual(1, x);
}
public void Test_AuditEvent_CustomSerializer()
{
var listEv = new List <AuditEvent>();
var listJson = new List <string>();
Audit.Core.Configuration.Setup()
.Use(x => x
.OnInsertAndReplace(ev =>
{
listEv.Add(ev);
listJson.Add(ev.ToJson());
}))
.WithCreationPolicy(EventCreationPolicy.InsertOnEnd);
var jSettings = new JsonSerializerSettings()
{
TypeNameHandling = TypeNameHandling.All
};
Audit.Core.Configuration.JsonSettings = jSettings;
using (var scope = new AuditScopeFactory().Create("TEST", null, null, null, null))
{
}
Assert.AreEqual(1, listEv.Count);
var manualJson = listEv[0].ToJson();
Audit.Core.Configuration.JsonSettings = new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore,
ReferenceLoopHandling = ReferenceLoopHandling.Ignore
};
Assert.AreEqual(1, listJson.Count);
var jsonExpected = JsonConvert.SerializeObject(listEv[0], jSettings);
Assert.AreEqual(jsonExpected, listJson[0]);
Assert.AreEqual(jsonExpected, manualJson);
Assert.AreEqual(JsonConvert.SerializeObject(listEv[0], new JsonSerializerSettings()), listEv[0].ToJson(new JsonSerializerSettings()));
}
public void Test_AuditScope_CallingMethod()
{
Audit.Core.Configuration.SystemClock = new MyClock();
var evs = new List <AuditEvent>();
Audit.Core.Configuration.Setup()
.Use(x => x.OnInsertAndReplace(ev => { evs.Add(ev); }))
.WithCreationPolicy(EventCreationPolicy.InsertOnEnd);
using (var scope = AuditScope.Create("test", () => "target"))
{
}
using (var scope = new AuditScopeFactory().Create("test", () => "target"))
{
}
Assert.AreEqual(2, evs.Count);
Assert.IsTrue(evs[0].Environment.CallingMethodName.Contains("Test_AuditScope_CallingMethod"));
Assert.IsTrue(evs[1].Environment.CallingMethodName.Contains("Test_AuditScope_CallingMethod"));
}
public void Test_UdpDataProvider_MultiThread(string ip, int port, bool multicast, int N)
{
stop = false;
events.Clear();
var p = new Udp.Providers.UdpDataProvider();
p.RemoteAddress = UdpProviderConfigurator.GetIPAddress(ip);
p.RemotePort = port;
var cts = new CancellationTokenSource();
var re = new ManualResetEvent(false);
var listener = Task.Factory.StartNew(() => { Listen(re, ip, port, multicast); }, cts.Token);
re.WaitOne();
Task.Delay(1500).Wait();
var tasks = new List <Task>();
for (int i = 0; i < N; i++)
{
int a = i;
tasks.Add(new Task(() =>
{
using (var scope = new AuditScopeFactory().Create("Test_UdpDataProvider_MultiThread_" + a, null, EventCreationPolicy.InsertOnEnd, p))
{
}
}));
}
for (int i = 0; i < N; i++)
{
tasks[i].Start();
}
Task.WaitAll(tasks.ToArray());
Task.Delay(1000).Wait();
stop = true;
cts.Cancel();
Task.Delay(1000).Wait();
Assert.AreEqual(N, events.Count);
Assert.IsTrue(events[0].EventType.StartsWith("Test_UdpDataProvider_MultiThread_"));
Assert.NotNull(events[0].CustomFields["UdpEventId"]);
}
