示例#1
0
        void ShouldSaveAndLoadRuleLinks()
        {
            var store     = ActionStoreFactory.GetActionStore();
            var ruleId    = Guid.NewGuid();
            var ruleId2   = Guid.NewGuid();
            var expected1 = (ConsoleLogAction)AlertActionFactory.Create("log to console", "Ajakka.Alerting.ConsoleLogAction", "{TimestampFormat:\"G\"}");
            var returned1 = store.AddAction(expected1);
            var expected2 = (LogToFileAction)AlertActionFactory.Create("log to console", "Ajakka.Alerting.LogToFileAction", "{FileName:\"log.log\"}");
            var returned2 = store.AddAction(expected1);
            var expected3 = (HttpRequestAlertAction)AlertActionFactory.Create("send http request", "Ajakka.Alerting.HttpRequestAlertAction", "{Url:\"http://google.com\"}");
            var returned3 = store.AddAction(expected3);

            store.LinkRuleToAction(ruleId, returned1.Id);
            store.LinkRuleToAction(ruleId, returned2.Id);
            store.LinkRuleToAction(ruleId2, returned3.Id);
            ((IAlertingStorage)store).Save("ShouldSaveAndLoadRuleLinks");
            var store2 = ActionStoreFactory.GetActionStore();

            ((IAlertingStorage)store2).Load("ShouldSaveAndLoadRuleLinks");

            var actions = store2.GetLinkedActions(ruleId);

            Assert.True(actions.Length == 2);
            var action1 = actions.First((a) => { return(a.Id == returned1.Id); });

            AssertActionsEqual(returned1, action1);
            var action2 = actions.First((a) => { return(a.Id == returned2.Id); });

            AssertActionsEqual(returned2, action2);

            var action3 = store2.GetLinkedActions(ruleId2).First((a) => { return(a.Id == returned3.Id); });

            AssertActionsEqual(returned3, action3);
        }
        public void BugFix_ShouldNotLogOutsideCurrentDirectory()
        {
            LogToFileAction alertAction = (LogToFileAction)AlertActionFactory.Create("log to file", "Ajakka.Alerting.LogToFileAction", "{\"TimestampFormat\":\"MM\",\"FileName\":\"c:\\\\alert.log\"}");
            var             store       = ActionStoreFactory.GetActionStore();
            var             added       = store.AddAction(alertAction);
            var             actual      = store.GetAction(added.Id);

            Assert.Equal("alert.log", ((LogToFileAction)actual).FileName);
        }
示例#3
0
        public void ShouldReturnEmptyPageWithActions()
        {
            var store = ActionStoreFactory.GetActionStore();

            for (int i = 0; i < 15; i++)
            {
                var action = (ConsoleLogAction)AlertActionFactory.Create("log to console " + i, "Ajakka.Alerting.ConsoleLogAction", "{TimestampFormat:\"G\"}");
                store.AddAction(action);
            }
            var firstPage = store.GetActions(3);

            Assert.True(0 == firstPage.Length);
        }
示例#4
0
        public void ShouldPageCount()
        {
            var store = ActionStoreFactory.GetActionStore();

            for (int i = 0; i < 15; i++)
            {
                var action = (ConsoleLogAction)AlertActionFactory.Create("log to console " + i, "Ajakka.Alerting.ConsoleLogAction", "{TimestampFormat:\"G\"}");
                store.AddAction(action);
            }
            var pageCount = store.GetPageCount();

            Assert.Equal(2, pageCount);
        }
示例#5
0
        public void ShouldLinkActionToBlacklistRule()
        {
            var store  = ActionStoreFactory.GetActionStore();
            var ruleId = Guid.NewGuid();
            ConsoleLogAction expected1 = (ConsoleLogAction)AlertActionFactory.Create("log to console", "Ajakka.Alerting.ConsoleLogAction", "{TimestampFormat:\"G\"}");
            var returned = store.AddAction(expected1);

            store.LinkRuleToAction(ruleId, returned.Id);
            var actions = store.GetLinkedActions(ruleId);

            Assert.True(actions.Length == 1);
            AssertActionsEqual(returned, actions[0], true);
        }
示例#6
0
        void BugTest_ShouldAddActionAfterLoading()
        {
            var actionStore = ActionStoreFactory.GetActionStore();

            actionStore.AddAction(AlertActionFactory.Create("action1", "Ajakka.Alerting.ConsoleLogAction", "{TimestampFormat:\"MM\"}"));
            actionStore.AddAction(AlertActionFactory.Create("action2", "Ajakka.Alerting.ConsoleLogAction", "{TimestampFormat:\"MM\"}"));
            actionStore.AddAction(AlertActionFactory.Create("action3", "Ajakka.Alerting.ConsoleLogAction", "{TimestampFormat:\"MM\"}"));
            ((IAlertingStorage)actionStore).Save("BugTest_ShouldAddActionAfterLoading");
            var actionStore2 = ActionStoreFactory.GetActionStore();

            ((IAlertingStorage)actionStore2).Load("BugTest_ShouldAddActionAfterLoading");
            var action2 = AlertActionFactory.Create("action", "Ajakka.Alerting.ConsoleLogAction", "{TimestampFormat:\"MM\"}");

            actionStore2.AddAction(action2);
        }
示例#7
0
        public void ShouldDeleteAction()
        {
            var store = ActionStoreFactory.GetActionStore();
            ConsoleLogAction expected1 = (ConsoleLogAction)AlertActionFactory.Create("log to console", "Ajakka.Alerting.ConsoleLogAction", "{TimestampFormat:\"G\"}");
            ConsoleLogAction expected2 = (ConsoleLogAction)AlertActionFactory.Create("log to console 2", "Ajakka.Alerting.ConsoleLogAction", "{TimestampFormat:\"MM\"}");
            var returned1 = store.AddAction(expected1);
            var returned2 = store.AddAction(expected2);

            store.DeleteAction(returned1.Id);
            var actual2 = store.GetAction(returned2.Id);

            AssertActionsEqual(expected2, actual2, false);
            AssertActionsEqual(returned2, actual2);
            Assert.Throws <KeyNotFoundException>(() => { store.GetAction(returned1.Id); });
        }
示例#8
0
        public void ShouldUpdateAction()
        {
            var store = ActionStoreFactory.GetActionStore();
            ConsoleLogAction expected1 = (ConsoleLogAction)AlertActionFactory.Create("log to console", "Ajakka.Alerting.ConsoleLogAction", "{TimestampFormat:\"G\"}");
            var returned = store.AddAction(expected1);

            expected1.Name            = "changed";
            expected1.TimestampFormat = "MM";
            expected1.Configuration   = "{TimestampFormat:\"MM\"}";

            store.UpdateAction(returned.Id, expected1);

            var actual = store.GetAction(returned.Id);

            AssertActionsEqual(expected1, actual, false);
        }
示例#9
0
        public void ShouldAddAndGetAlertActions()
        {
            var store = ActionStoreFactory.GetActionStore();
            ConsoleLogAction expected1 = (ConsoleLogAction)AlertActionFactory.Create("log to console", "Ajakka.Alerting.ConsoleLogAction", "{TimestampFormat:\"G\"}");
            ConsoleLogAction expected2 = (ConsoleLogAction)AlertActionFactory.Create("log to console 2", "Ajakka.Alerting.ConsoleLogAction", "{TimestampFormat:\"MM\"}");

            var returned1 = store.AddAction(expected1);
            var returned2 = store.AddAction(expected2);

            var actual1 = store.GetAction(returned1.Id);
            var actual2 = store.GetAction(returned2.Id);

            AssertActionsEqual(expected1, actual1, false);
            AssertActionsEqual(expected2, actual2, false);
            AssertActionsEqual(returned1, actual1);
            AssertActionsEqual(returned2, actual2);
        }
示例#10
0
        public void ShouldReturnSecondPageWithActions()
        {
            var store = ActionStoreFactory.GetActionStore();

            for (int i = 0; i < 15; i++)
            {
                var action = (ConsoleLogAction)AlertActionFactory.Create("log to console " + i, "Ajakka.Alerting.ConsoleLogAction", "{TimestampFormat:\"G\"}");
                store.AddAction(action);
            }
            var firstPage = store.GetActions(1);

            Assert.Equal(5, firstPage.Length);
            for (int i = 0, j = 10; i < 5; i++, j++)
            {
                Assert.Equal("log to console " + j, firstPage[i].Name);
            }
        }
示例#11
0
        void ShouldSaveAndLoadActions()
        {
            var actionStore = ActionStoreFactory.GetActionStore();
            List <AlertActionBase> actions = new List <AlertActionBase>();

            for (int i = 0; i < 50; i++)
            {
                var action = AlertActionFactory.Create("action " + i, "Ajakka.Alerting.ConsoleLogAction", "{TimestampFormat:\"MM\"}");
                action.Initialize();
                var added = actionStore.AddAction(action);
                action.Id = added.Id;
                actions.Add(action);
            }
            for (int i = 50; i < 100; i++)
            {
                var action = AlertActionFactory.Create("action " + i, "Ajakka.Alerting.LogToFileAction", "{TimestampFormat:\"MM\",FileName:\"log.log\"}");
                action.Initialize();
                var added = actionStore.AddAction(action);
                action.Id = added.Id;
                actions.Add(action);
            }

            ((IAlertingStorage)actionStore).Save("ShouldSaveAndLoadActions");
            var actionStore2 = ActionStoreFactory.GetActionStore();
            var action2      = AlertActionFactory.Create("action e", "Ajakka.Alerting.LogToFileAction", "{TimestampFormat:\"MM\",FileName:\"log.log\"}");

            actionStore2.AddAction(action2);

            ((IAlertingStorage)actionStore2).Load("ShouldSaveAndLoadActions");


            foreach (var expected in actions)
            {
                var actual = actionStore2.GetAction(expected.Id);
                AssertActionsEqual(expected, actual);
            }

            var loadedActions = new List <AlertActionBase>();

            for (int i = 0; i < actionStore2.GetPageCount(); i++)
            {
                loadedActions.AddRange(actionStore2.GetActions(i));
            }
            Assert.True(loadedActions.Count == 100);
        }
示例#12
0
        public void ShouldDeleteRuleAndLinkedActions()
        {
            var store     = ActionStoreFactory.GetActionStore();
            var ruleId    = Guid.NewGuid();
            var ruleId2   = Guid.NewGuid();
            var expected1 = (ConsoleLogAction)AlertActionFactory.Create("log to console", "Ajakka.Alerting.ConsoleLogAction", "{TimestampFormat:\"G\"}");
            var returned1 = store.AddAction(expected1);
            var expected2 = (LogToFileAction)AlertActionFactory.Create("log to console", "Ajakka.Alerting.LogToFileAction", "{FileName:\"log.log\"}");
            var returned2 = store.AddAction(expected1);
            var expected3 = (HttpRequestAlertAction)AlertActionFactory.Create("send http request", "Ajakka.Alerting.HttpRequestAlertAction", "{Url:\"http://google.com\"}");
            var returned3 = store.AddAction(expected3);

            store.LinkRuleToAction(ruleId, returned1.Id);
            store.LinkRuleToAction(ruleId, returned2.Id);
            store.LinkRuleToAction(ruleId2, returned3.Id);

            store.DeleteRuleAndActions(ruleId);
            Assert.Throws <KeyNotFoundException>(() => { store.GetAction(returned1.Id); });
            Assert.Throws <KeyNotFoundException>(() => { store.GetAction(returned2.Id); });
            store.GetAction(returned3.Id);
            var linkedActions = store.GetLinkedActions(ruleId);

            Assert.True(linkedActions.Length == 0);
        }