Added tests

Author: kichalla

test/Microsoft.AspNetCore.Hosting.Tests/Internal/HostingEventSourceTests.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Diagnostics.Tracing;
 using System.Reflection;
+using Microsoft.AspNetCore.Http;
 using Xunit;
 
 namespace Microsoft.AspNetCore.Hosting.Internal
@@ -25,5 +26,202 @@ public void MatchesNameAndGuid()
             Assert.Equal(Guid.Parse("9e620d2a-55d4-5ade-deb7-c26046d245a8"), EventSource.GetGuid(eventSourceType));
             Assert.NotEmpty(EventSource.GenerateManifest(eventSourceType, "assemblyPathToIncludeInManifest"));
         }
+
+        [Fact]
+        public void HostStart()
+        {
+            // Arrange
+            var expectedEventId = 1;
+            var eventListener = new TestEventListener(expectedEventId);
+            var hostingEventSource = HostingEventSource.Log;
+            eventListener.EnableEvents(hostingEventSource, EventLevel.Informational);
+
+            // Act
+            hostingEventSource.HostStart();
+
+            // Assert
+            var eventData = eventListener.EventData;
+            Assert.NotNull(eventData);
+            Assert.Equal(expectedEventId, eventData.EventId);
+#if NETCOREAPP1_1
+            Assert.Equal("HostStart", eventData.EventName);
+#endif
+            Assert.Equal(EventLevel.Informational, eventData.Level);
+            Assert.Same(hostingEventSource, eventData.EventSource);
+            Assert.Null(eventData.Message);
+            Assert.Empty(eventData.Payload);
+        }
+
+        [Fact]
+        public void HostStop()
+        {
+            // Arrange
+            var expectedEventId = 2;
+            var eventListener = new TestEventListener(expectedEventId);
+            var hostingEventSource = HostingEventSource.Log;
+            eventListener.EnableEvents(hostingEventSource, EventLevel.Informational);
+
+            // Act
+            hostingEventSource.HostStop();
+
+            // Assert
+            var eventData = eventListener.EventData;
+            Assert.NotNull(eventData);
+            Assert.Equal(expectedEventId, eventData.EventId);
+#if NETCOREAPP1_1
+            Assert.Equal("HostStop", eventData.EventName);
+#endif
+            Assert.Equal(EventLevel.Informational, eventData.Level);
+            Assert.Same(hostingEventSource, eventData.EventSource);
+            Assert.Null(eventData.Message);
+            Assert.Empty(eventData.Payload);
+        }
+
+        public static TheoryData<DefaultHttpContext, string[]> RequestStartData
+        {
+            get
+            {
+                var variations = new TheoryData<DefaultHttpContext, string[]>();
+
+                var context = new DefaultHttpContext();
+                context.Request.Method = "GET";
+                context.Request.Path = "/Home/Index";
+                variations.Add(
+                    context,
+                    new string[]
+                    {
+                        "GET",
+                        "/Home/Index"
+                    });
+
+                context = new DefaultHttpContext();
+                context.Request.Method = "POST";
+                context.Request.Path = "/";
+                variations.Add(
+                    context,
+                    new string[]
+                    {
+                        "POST",
+                        "/"
+                    });
+
+                return variations;
+            }
+        }
+
+        [Theory]
+        [MemberData(nameof(RequestStartData))]
+        public void RequestStart(DefaultHttpContext httpContext, string[] expected)
+        {
+            // Arrange
+            var expectedEventId = 3;
+            var eventListener = new TestEventListener(expectedEventId);
+            var hostingEventSource = HostingEventSource.Log;
+            eventListener.EnableEvents(hostingEventSource, EventLevel.Informational);
+
+            // Act
+            hostingEventSource.RequestStart(httpContext.Request.Method, httpContext.Request.Path);
+
+            // Assert
+            var eventData = eventListener.EventData;
+            Assert.NotNull(eventData);
+            Assert.Equal(expectedEventId, eventData.EventId);
+#if NETCOREAPP1_1
+            Assert.Equal("RequestStart", eventData.EventName);
+#endif
+            Assert.Equal(EventLevel.Informational, eventData.Level);
+            Assert.Same(hostingEventSource, eventData.EventSource);
+            Assert.Null(eventData.Message);
+
+            var payloadList = eventData.Payload;
+            Assert.Equal(expected.Length, payloadList.Count);
+            for (var i = 0; i < expected.Length; i++)
+            {
+                Assert.Equal(expected[i], payloadList[i]);
+            }
+        }
+
+        [Fact]
+        public void RequestStop()
+        {
+            // Arrange
+            var expectedEventId = 4;
+            var eventListener = new TestEventListener(expectedEventId);
+            var hostingEventSource = HostingEventSource.Log;
+            eventListener.EnableEvents(hostingEventSource, EventLevel.Informational);
+
+            // Act
+            hostingEventSource.RequestStop();
+
+            // Assert
+            var eventData = eventListener.EventData;
+            Assert.Equal(expectedEventId, eventData.EventId);
+#if NETCOREAPP1_1
+            Assert.Equal("RequestStop", eventData.EventName);
+#endif
+            Assert.Equal(EventLevel.Informational, eventData.Level);
+            Assert.Same(hostingEventSource, eventData.EventSource);
+            Assert.Null(eventData.Message);
+            Assert.Equal(0, eventData.Payload.Count);
+        }
+
+        [Fact]
+        public void UnhandledException()
+        {
+            // Arrange
+            var expectedEventId = 5;
+            var eventListener = new TestEventListener(expectedEventId);
+            var hostingEventSource = HostingEventSource.Log;
+            eventListener.EnableEvents(hostingEventSource, EventLevel.Informational);
+
+            // Act
+            hostingEventSource.UnhandledException();
+
+            // Assert
+            var eventData = eventListener.EventData;
+            Assert.Equal(expectedEventId, eventData.EventId);
+#if NETCOREAPP1_1
+            Assert.Equal("UnhandledException", eventData.EventName);
+#endif
+            Assert.Equal(EventLevel.Error, eventData.Level);
+            Assert.Same(hostingEventSource, eventData.EventSource);
+            Assert.Null(eventData.Message);
+            Assert.Equal(0, eventData.Payload.Count);
+        }
+
+        private static Exception GetException()
+        {
+            try
+            {
+                throw new InvalidOperationException("An invalid operation has occurred");
+            }
+            catch (Exception ex)
+            {
+                return ex;
+            }
+        }
+
+        private class TestEventListener : EventListener
+        {
+            private readonly int _eventId;
+
+            public TestEventListener(int eventId)
+            {
+                _eventId = eventId;
+            }
+
+            public EventWrittenEventArgs EventData { get; private set; }
+
+            protected override void OnEventWritten(EventWrittenEventArgs eventData)
+            {
+                // The tests here run in parallel and since the single publisher instance (HostingEventingSource)
+                // notifies all listener instances in these tests, capture the EventData that a test is explicitly
+                // looking for and not give back other tests' data.
+                if (eventData.EventId == _eventId)
+                {
+                    EventData = eventData;
+                }
+            }
+        }
     }
 }