Пример #1
0
        public void AlwaysCaseInsensitive()
        {
            var e = new SystemEvent { Message = "Start MESSAGE End" };
            var extendedProperties = new FakeExtendedProperties { { "property", "Message" }, { "value", "Message" } };
            var filter = new ContainsFilter(extendedProperties, Enumerable.Empty<ICreateFilterExpressions>());

            Assert.True(Filter.Compile(filter).Invoke(e));
        }
Пример #2
0
        public void ReturnFalseIfNoChildFilters()
        {
            var e = new SystemEvent();
            var extendedProperties = new FakeExtendedProperties { { "property", "Level" }, { "value", "Warning" } };
            var filter = new NotFilter(extendedProperties, Enumerable.Empty<ICreateFilterExpressions>());

            Assert.False(Filter.Compile(filter).Invoke(e));
        }
        public void ReturnTrueIfEqual()
        {
            var e = new SystemEvent { Level = SystemEventLevel.Warning };
            var extendedProperties = new FakeExtendedProperties { { "property", "Level" }, { "value", "Warning" } };
            var filter = new EqualFilter(extendedProperties, Enumerable.Empty<ICreateFilterExpressions>());

            Assert.True(Filter.Compile(filter).Invoke(e));
        }
Пример #4
0
        public void ReturnTrueIfStringContainsValue()
        {
            var e = new SystemEvent { Message = "Start Message End" };
            var extendedProperties = new FakeExtendedProperties { { "property", "Message" }, { "value", "Message" } };
            var filter = new ContainsFilter(extendedProperties, Enumerable.Empty<ICreateFilterExpressions>());

            Assert.True(Filter.Compile(filter).Invoke(e));
        }
Пример #5
0
        public void ReturnFalseIfSingleChildFilterFalse()
        {
            var e = new SystemEvent { Level = SystemEventLevel.Error };
            var extendedProperties = new FakeExtendedProperties { { "property", "Level" }, { "value", "Warning" } };
            var filter = new OrElseFilter(new FakeExtendedProperties(), new[] { new EqualFilter(extendedProperties, Enumerable.Empty<ICreateFilterExpressions>()) });

            Assert.False(Filter.Compile(filter).Invoke(e));
        }
        public void CanHaveNullValue()
        {
            var e = new SystemEvent { Message = "Start of Message" };
            var extendedProperties = new FakeExtendedProperties { { "property", "Message" }, { "value", null } };
            var filter = new StartsWithFilter(extendedProperties, Enumerable.Empty<ICreateFilterExpressions>());

            Assert.True(Filter.Compile(filter).Invoke(e));
        }
        public void ReturnTrueIfLessThanOrEqual()
        {
            var e = new SystemEvent { ProcessId = 50 };
            var extendedProperties = new FakeExtendedProperties { { "property", "ProcessId" }, { "value", "50" } };
            var filter = new LessThanOrEqualFilter(extendedProperties, Enumerable.Empty<ICreateFilterExpressions>());

            Assert.True(Filter.Compile(filter).Invoke(e));
        }
Пример #8
0
        public void ValueCanBeUInt32()
        {
            var e = new SystemEvent();
            var extendedProperties = new FakeExtendedProperties { { "property", "MessageId" }, { "value", e.MessageId.ToString(CultureInfo.InvariantCulture) } };
            var filter = new EqualFilter(extendedProperties, Enumerable.Empty<ICreateFilterExpressions>());

            Assert.True(Filter.Compile(filter).Invoke(e));
        }
Пример #9
0
        public void CanHaveNullProperty()
        {
            var e = new SystemEvent { Message = null };
            var extendedProperties = new FakeExtendedProperties { { "property", "Message" }, { "value", "Message" } };
            var filter = new ContainsFilter(extendedProperties, Enumerable.Empty<ICreateFilterExpressions>());

            Assert.False(Filter.Compile(filter).Invoke(e));
        }
Пример #10
0
        public void ValueCanBeInt32()
        {
            var e = new SystemEvent { ProcessId = 123 };
            var extendedProperties = new FakeExtendedProperties { { "property", "ProcessId" }, { "value", "123" } };
            var filter = new EqualFilter(extendedProperties, Enumerable.Empty<ICreateFilterExpressions>());

            Assert.True(Filter.Compile(filter).Invoke(e));
        }
Пример #11
0
        public void ValueCanBeString()
        {
            var e = new SystemEvent { Message = "My Message" };
            var extendedProperties = new FakeExtendedProperties { { "property", "Message" }, { "value", "My Message" } };
            var filter = new EqualFilter(extendedProperties, Enumerable.Empty<ICreateFilterExpressions>());

            Assert.True(Filter.Compile(filter).Invoke(e));
        }
        public void ReturnFalseIfNotGreaterThan()
        {
            var e = new SystemEvent { ProcessId = 50 };
            var extendedProperties = new FakeExtendedProperties { { "property", "ProcessId" }, { "value", "50" } };
            var filter = new GreaterThanFilter(extendedProperties, Enumerable.Empty<ICreateFilterExpressions>());

            Assert.False(Filter.Compile(filter).Invoke(e));
        }
        public void ReturnFalseIfStringDoesNotStartWithValue()
        {
            var e = new SystemEvent { Message = " Start of Message" };
            var extendedProperties = new FakeExtendedProperties { { "property", "Message" }, { "value", "Start" } };
            var filter = new StartsWithFilter(extendedProperties, Enumerable.Empty<ICreateFilterExpressions>());

            Assert.False(Filter.Compile(filter).Invoke(e));
        }
Пример #14
0
        public void ValueCanBeDateTime()
        {
            var now = DateTime.Now;
            var e = new SystemEvent { Timestamp = new DateTime(now.Year, now.Month, now.Day, now.Hour, now.Minute, now.Second) };
            var extendedProperties = new FakeExtendedProperties { { "property", "Timestamp" }, { "value", now.ToString("yyyy-MM-dd HH:mm:ss") } };
            var filter = new EqualFilter(extendedProperties, Enumerable.Empty<ICreateFilterExpressions>());

            Assert.True(Filter.Compile(filter).Invoke(e));
        }
Пример #15
0
        public void ReturnTrueIfNoChildFilters()
        {
            var e = new SystemEvent();
            var extendedProperties = new FakeExtendedProperties {
                { "property", "Level" }, { "value", "Warning" }
            };
            var filter = new OrElseFilter(extendedProperties, Enumerable.Empty <ICreateFilterExpressions>());

            Assert.True(Filter.Compile(filter).Invoke(e));
        }
Пример #16
0
        public void ValueCanBeUInt32()
        {
            var e = new SystemEvent();
            var extendedProperties = new FakeExtendedProperties {
                { "property", "MessageId" }, { "value", e.MessageId.ToString(CultureInfo.InvariantCulture) }
            };
            var filter = new EqualFilter(extendedProperties, Enumerable.Empty <ICreateFilterExpressions>());

            Assert.True(Filter.Compile(filter).Invoke(e));
        }
        public WhenParsingGroupedMessage()
        {
            var extendedProperties = new FakeExtendedProperties
            {
                { "pattern", @"(?<logger>[^:]+): (?<level>[A-Z]+) \[(?<thread>[\d])\] - (?<username>[\w]+) - (?<message>(.*\r*\n*)*)" },
                { "options", "ExplicitCapture,IgnoreCase" }
            };

            messageParser = new RegexParser(processRetriever.Object, extendedProperties);
        }
        public void ReturnTrueIfFilterExpressionIsNotSatisfied()
        {
            var extendedProperties = new FakeExtendedProperties { { "property", "Level" }, { "value", "Fatal" } };
            var systemEvent = Expression.Parameter(typeof(SystemEvent), "e");
            var filterParameters = new FilterParameters { systemEvent };

            var filter = new StaticFilterExpression(systemEvent, new EqualFilter(extendedProperties, Enumerable.Empty<ICreateFilterExpressions>()).CreateExpression(filterParameters));

            Assert.True(filter.Exclude(new SystemEvent { Level = SystemEventLevel.Error }));
        }
        public WhenParsingGroupedMessage()
        {
            var extendedProperties = new FakeExtendedProperties
                                         {
                                             { "pattern", @"(?<logger>[^:]+): (?<level>[A-Z]+) \[(?<thread>[\d])\] - (?<username>[\w]+) - (?<message>(.*\r*\n*)*)" },
                                             { "options", "ExplicitCapture,IgnoreCase" }
                                         };

            messageParser = new RegexParser(processRetriever.Object, extendedProperties);
        }
Пример #20
0
        public WhenParsingNonGroupedMessage()
        {
            var extendedProperties = new FakeExtendedProperties
            {
                { "pattern", @"[^:]+: [A-Z]{5} \[[\d]\] - [\w]+ - .*" },
                { "options", "IgnoreCase" }
            };

            messageParser = new RegexParser(processRetriever.Object, extendedProperties);
        }
        public WhenCheckingCanParseMessage()
        {
            var extendedProperties = new FakeExtendedProperties
            {
                { "pattern", "ExactMatch" },
                { "options", "None" }
            };

            messageParser = new RegexParser(processRetriever.Object, extendedProperties);
        }
        public WhenCheckingCanParseMessage()
        {
            var extendedProperties = new FakeExtendedProperties
                                         {
                                             { "pattern", "ExactMatch" },
                                             { "options", "None" }
                                         };

            messageParser = new RegexParser(processRetriever.Object, extendedProperties);
        }
        public WhenParsingNonGroupedMessage()
        {
            var extendedProperties = new FakeExtendedProperties
                                         {
                                             { "pattern", @"[^:]+: [A-Z]{5} \[[\d]\] - [\w]+ - .*" },
                                             { "options", "IgnoreCase" }
                                         };

            messageParser = new RegexParser(processRetriever.Object, extendedProperties);
        }
        public void ReturnTrueIfGreaterThan()
        {
            var e = new SystemEvent {
                ProcessId = 51
            };
            var extendedProperties = new FakeExtendedProperties {
                { "property", "ProcessId" }, { "value", "50" }
            };
            var filter = new GreaterThanFilter(extendedProperties, Enumerable.Empty <ICreateFilterExpressions>());

            Assert.True(Filter.Compile(filter).Invoke(e));
        }
        public void ReturnFalseIfNotLessThanOrEqual()
        {
            var e = new SystemEvent {
                ProcessId = 51
            };
            var extendedProperties = new FakeExtendedProperties {
                { "property", "ProcessId" }, { "value", "50" }
            };
            var filter = new LessThanOrEqualFilter(extendedProperties, Enumerable.Empty <ICreateFilterExpressions>());

            Assert.False(Filter.Compile(filter).Invoke(e));
        }
Пример #26
0
        public void ReturnFalseIfEqual()
        {
            var e = new SystemEvent {
                Level = SystemEventLevel.Error
            };
            var extendedProperties = new FakeExtendedProperties {
                { "property", "Level" }, { "value", "Warning" }
            };
            var filter = new NotEqualFilter(extendedProperties, Enumerable.Empty <ICreateFilterExpressions>());

            Assert.True(Filter.Compile(filter).Invoke(e));
        }
Пример #27
0
        public void ValueCanBeInt32()
        {
            var e = new SystemEvent {
                ProcessId = 123
            };
            var extendedProperties = new FakeExtendedProperties {
                { "property", "ProcessId" }, { "value", "123" }
            };
            var filter = new EqualFilter(extendedProperties, Enumerable.Empty <ICreateFilterExpressions>());

            Assert.True(Filter.Compile(filter).Invoke(e));
        }
        public void ReturnTrueIfStringStartsWithValue()
        {
            var e = new SystemEvent {
                Message = "Start of Message"
            };
            var extendedProperties = new FakeExtendedProperties {
                { "property", "Message" }, { "value", "Start" }
            };
            var filter = new StartsWithFilter(extendedProperties, Enumerable.Empty <ICreateFilterExpressions>());

            Assert.True(Filter.Compile(filter).Invoke(e));
        }
        public void CanHaveNullProperty()
        {
            var e = new SystemEvent {
                Message = null
            };
            var extendedProperties = new FakeExtendedProperties {
                { "property", "Message" }, { "value", "Message" }
            };
            var filter = new ContainsFilter(extendedProperties, Enumerable.Empty <ICreateFilterExpressions>());

            Assert.False(Filter.Compile(filter).Invoke(e));
        }
Пример #30
0
        public void CanHaveNullValue()
        {
            var e = new SystemEvent {
                Message = "Message Ends"
            };
            var extendedProperties = new FakeExtendedProperties {
                { "property", "Message" }, { "value", null }
            };
            var filter = new EndsWithFilter(extendedProperties, Enumerable.Empty <ICreateFilterExpressions>());

            Assert.True(Filter.Compile(filter).Invoke(e));
        }
Пример #31
0
        public void ValueCanBeString()
        {
            var e = new SystemEvent {
                Message = "My Message"
            };
            var extendedProperties = new FakeExtendedProperties {
                { "property", "Message" }, { "value", "My Message" }
            };
            var filter = new EqualFilter(extendedProperties, Enumerable.Empty <ICreateFilterExpressions>());

            Assert.True(Filter.Compile(filter).Invoke(e));
        }
Пример #32
0
        public void AlwaysCaseInsensitive()
        {
            var e = new SystemEvent {
                Message = "Message ENDS"
            };
            var extendedProperties = new FakeExtendedProperties {
                { "property", "Message" }, { "value", "Ends" }
            };
            var filter = new EndsWithFilter(extendedProperties, Enumerable.Empty <ICreateFilterExpressions>());

            Assert.True(Filter.Compile(filter).Invoke(e));
        }
Пример #33
0
        public void ReturnFalseIfStringDoesNotEndWithValue()
        {
            var e = new SystemEvent {
                Message = "Message Ends "
            };
            var extendedProperties = new FakeExtendedProperties {
                { "property", "Message" }, { "value", "Ends" }
            };
            var filter = new EndsWithFilter(extendedProperties, Enumerable.Empty <ICreateFilterExpressions>());

            Assert.False(Filter.Compile(filter).Invoke(e));
        }
Пример #34
0
        public void ReturnFalseIfSingleChildFilterFalse()
        {
            var e = new SystemEvent {
                Level = SystemEventLevel.Error
            };
            var extendedProperties = new FakeExtendedProperties {
                { "property", "Level" }, { "value", "Warning" }
            };
            var filter = new OrElseFilter(new FakeExtendedProperties(), new[] { new EqualFilter(extendedProperties, Enumerable.Empty <ICreateFilterExpressions>()) });

            Assert.False(Filter.Compile(filter).Invoke(e));
        }
Пример #35
0
        public void ValueCanBeDateTime()
        {
            var now = DateTime.Now;
            var e   = new SystemEvent {
                Timestamp = new DateTime(now.Year, now.Month, now.Day, now.Hour, now.Minute, now.Second)
            };
            var extendedProperties = new FakeExtendedProperties {
                { "property", "Timestamp" }, { "value", now.ToString("yyyy-MM-dd HH:mm:ss") }
            };
            var filter = new EqualFilter(extendedProperties, Enumerable.Empty <ICreateFilterExpressions>());

            Assert.True(Filter.Compile(filter).Invoke(e));
        }
Пример #36
0
        public void ReturnTrueIfFilterExpressionIsNotSatisfied()
        {
            var extendedProperties = new FakeExtendedProperties {
                { "property", "Level" }, { "value", "Fatal" }
            };
            var systemEvent      = Expression.Parameter(typeof(SystemEvent), "e");
            var filterParameters = new FilterParameters {
                systemEvent
            };

            var filter = new StaticFilterExpression(systemEvent, new EqualFilter(extendedProperties, Enumerable.Empty <ICreateFilterExpressions>()).CreateExpression(filterParameters));

            Assert.True(filter.Exclude(new SystemEvent {
                Level = SystemEventLevel.Error
            }));
        }