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"]); }