public void Log_WithFailingImplementationAndConfiguredFallbackProvider_LogsOriginalFailureToFallbackProvider()
        {
            // Arrange
            var failingProvider = new ThrowingLoggingProvider();

            failingProvider.Initialize("Failing provider name", new NameValueCollection());

            var fallbackProvider = new MemoryLoggingProvider();

            failingProvider.FallbackProvider = fallbackProvider;
            failingProvider.ExceptionToThrowFromLogInternal = new InvalidOperationException();
            var expectedEntry =
                new LogEntry(LoggingEventType.Error,
                             "The event could not be logged with provider 'Failing provider name'.",
                             "CuttingEdge.Logging.Tests.Unit.LoggingProviderBaseTests+ThrowingLoggingProvider",
                             failingProvider.ExceptionToThrowFromLogInternal);

            // Act
            failingProvider.Log("Valid message");

            // Assert
            var loggedEntry = fallbackProvider.GetLoggedEntries().Last();

            AssertHelper.LogEntriesAreEqual(expectedEntry, loggedEntry);
        }
Example #2
0
        private static MemoryLoggingProvider CreateInitializedMemoryLogger(string name)
        {
            var provider = new MemoryLoggingProvider();

            provider.Initialize(name, new NameValueCollection());

            return(provider);
        }
        public void Initialize_WithValidArguments_Succeeds()
        {
            // Arrange
            var provider           = new MemoryLoggingProvider();
            var validConfiguration = CreateValidConfiguration();

            // Act
            provider.Initialize("Valid name", validConfiguration);
        }
        public void Initialize_WithNullConfiguration_ThrowsException()
        {
            // Arrange
            var provider = new MemoryLoggingProvider();
            NameValueCollection invalidConfiguration = null;

            // Act
            provider.Initialize("Valid name", invalidConfiguration);
        }
        private static MemoryLoggingProvider CreateInitializedMemoryLoggingProvider()
        {
            var provider           = new MemoryLoggingProvider();
            var validConfiguration = CreateValidConfiguration();

            provider.Initialize("MemoryLoggingProvider", validConfiguration);

            return(provider);
        }
        public void Log_InitializedProvider_Succeeds()
        {
            // Arrange
            var provider = new MemoryLoggingProvider();

            provider.Initialize("Valid name", CreateValidConfiguration());

            // Act
            provider.Log("Some message");
        }
        public void Add_WithValidArgument_Succeeds()
        {
            // Arrange
            var collection    = new LoggingProviderCollection();
            var validProvider = new MemoryLoggingProvider();

            validProvider.Initialize("Valid provider name", new NameValueCollection());

            // Act
            collection.Add(validProvider);
        }
        public void Initialize_ConfigurationWithUnrecognizedAttributes_ThrowsException()
        {
            // Arrange
            var provider = new MemoryLoggingProvider();
            var configurationWithUnrecognizedAttribute = CreateValidConfiguration();

            configurationWithUnrecognizedAttribute.Add("unknown attribute", "some value");

            // Act
            provider.Initialize("Valid name", configurationWithUnrecognizedAttribute);
        }
Example #9
0
        public void FallbackProvider_ConstructorSuppliedWithFallbackProvider_ReturnsThatInstance()
        {
            // Arrange
            var expectedFallbackProvider = new MemoryLoggingProvider();

            // Act
            var provider = CreateValidXmlFileLogger(expectedFallbackProvider);

            // Assert
            Assert.AreEqual(expectedFallbackProvider, provider.FallbackProvider);
        }
        public void Log_WithValidEntry_AddsEntryToCollection()
        {
            // Arrange
            MemoryLoggingProvider provider = CreateInitializedMemoryLoggingProvider();
            LogEntry expectedEntry         = new LogEntry(LoggingEventType.Critical, "Valid message", null, null);

            // Act
            ((ILogger)provider).Log(expectedEntry);

            // Assert
            Assert.AreEqual(expectedEntry, provider.GetLoggedEntries().First());
        }
        public void Log_ProviderInitializedWithDebugThresholdThroughConstructor_LogsMessage()
        {
            // Arrange
            var expectedMessage = "Hello";
            var provider        = new MemoryLoggingProvider(LoggingEventType.Debug);

            // Act
            provider.Log(expectedMessage);

            // Assert
            Assert.AreEqual(1, provider.GetLoggedEntries().Length, "Message not logged");
        }
Example #12
0
        public void Log_CodeConfiguredFailingProvider_LogsToFallbackProvider()
        {
            // Arrange
            var fallbackProvider = new MemoryLoggingProvider();
            var provider         = new FailingWindowsEventLogLoggingProvider(fallbackProvider);

            // Act
            provider.Log("Message");

            // Assert
            Assert.AreEqual(2, fallbackProvider.GetLoggedEntries().Length, "Two messages are expected to be logged.");
        }
        public void Log_ProviderInitializedWithCriticalThresholdThroughConstructor_DoesNotLogMessage()
        {
            // Arrange
            var expectedMessage = "Hello";
            var provider        = new MemoryLoggingProvider(LoggingEventType.Critical);

            // Act
            provider.Log(expectedMessage);

            // Assert
            Assert.AreEqual(0, provider.GetLoggedEntries().Length, "Message was expected not to be logged");
        }
        public void Log_CodeConfiguredFailingProvider_LogsToFallbackProvider()
        {
            // Arrange
            var fallbackProvider = new MemoryLoggingProvider(LoggingEventType.Debug);

            var provider = new FailingSqlLoggingProvider(fallbackProvider);

            // Act
            provider.Log("Test");

            // Assert
            Assert.AreEqual(2, fallbackProvider.GetLoggedEntries().Length, "To events were expected to be logged.");
        }
        public void Initialize_ConfigurationWithoutDescription_SetsDefaultDescription()
        {
            // Arrange
            var expectedDescription = "Memory logging provider";
            var provider            = new MemoryLoggingProvider();
            var validConfiguration  = CreateValidConfiguration();

            // Act
            provider.Initialize("Valid provider name", validConfiguration);

            // Assert
            Assert.AreEqual(expectedDescription, provider.Description);
        }
        public void Clear_OnANonEmptyProvivder_ResultsInAnEmptyLoggedEntriesCollection()
        {
            // Arrange
            MemoryLoggingProvider provider = CreateInitializedMemoryLoggingProvider();

            provider.Log("Valid message");
            int expectedNumberOfEntriesAfterCallingClear = 0;

            // Act
            provider.Clear();

            // Assert
            Assert.AreEqual(expectedNumberOfEntriesAfterCallingClear, provider.GetLoggedEntries().Length);
        }
Example #17
0
        public void Log_CodeConfiguredFailingProvider_LogsToFallbackProvider()
        {
            // Arrange
            var fallbackProvider = new MemoryLoggingProvider();

            var provider = new FakeAspNetSqlLoggingProvider(fallbackProvider);

            provider.ExceptionToThrowFromLogInternal = new Exception();

            // Act
            provider.Log("Message");

            // Assert
            Assert.AreEqual(2, fallbackProvider.GetLoggedEntries().Length, "Logging failed.");
        }
        public void Initialize_ConfigurationWithCustomDescription_SetsSpecifiedDescription()
        {
            // Arrange
            var expectedDescription = "My memory logger";
            var provider            = new MemoryLoggingProvider();
            var validConfiguration  = CreateValidConfiguration();

            validConfiguration["description"] = expectedDescription;

            // Act
            provider.Initialize("Valid provider name", validConfiguration);

            // Assert
            Assert.AreEqual(expectedDescription, provider.Description);
        }
Example #19
0
        public void Log_WithProviderInitializedWithCustomConstructor_LogsToAllSuppliedProviders()
        {
            // Arrange
            var provider1 = new MemoryLoggingProvider();
            var provider2 = new MemoryLoggingProvider();

            var provider =
                new CompositeLoggingProvider(LoggingEventType.Debug, null, provider1, provider2);

            // Act
            provider.Log("Test");

            // Assert
            Assert.AreEqual(1, provider1.GetLoggedEntries().Count(), "CompositeLoggingProvider did not log.");
            Assert.AreEqual(1, provider2.GetLoggedEntries().Count(), "CompositeLoggingProvider did not log.");
        }
        public void Log_ProviderInitializedWithDefaultConstructor_LogsSuccesfully()
        {
            // Arrange
            string expectedMessage = "Some message";

            var provider = new MemoryLoggingProvider();

            // Act
            // In contrast with most other providers, this provider should succeed in logging the event when
            // it was created with the default constructor, and not initialized with Initialize(string, NVC).
            // This behavior is different, because the the only initialization argument the provider needs is
            // the severity, which will be retain its default value of 'Debug' when not set.
            provider.Log(LoggingEventType.Debug, expectedMessage);

            // Arrange
            Assert.AreEqual(1, provider.GetLoggedEntries().Length, "The provider did not log.");
        }
        public void Log_WithFailingImplementationAndConfiguredFallbackProvider_LogsEventToFallbackProvider()
        {
            // Arrange
            var failingProvider  = new ThrowingLoggingProvider();
            var fallbackProvider = new MemoryLoggingProvider();

            failingProvider.FallbackProvider = fallbackProvider;
            failingProvider.ExceptionToThrowFromLogInternal = new InvalidOperationException();
            var entryToLog = new LogEntry(LoggingEventType.Critical, "Valid message", null, null);

            // Act
            ((ILogger)failingProvider).Log(entryToLog);

            // Assert
            var loggedEntry = fallbackProvider.GetLoggedEntries().First();

            Assert.AreEqual(entryToLog, loggedEntry);
        }
        public void Log_WithValidEntry_ReturnsAnUniqueNumberPerCall()
        {
            // Arrange
            MemoryLoggingProvider provider = CreateInitializedMemoryLoggingProvider();

            // Act
            int id0 = (int)provider.Log("Valid message");
            int id1 = (int)provider.Log("Valid message");
            int id2 = (int)provider.Log("Valid message");
            int id3 = (int)provider.Log("Valid message");
            int id4 = (int)provider.Log("Valid message");

            // Assert
            Assert.AreEqual(0, id0);
            Assert.AreEqual(1, id1);
            Assert.AreEqual(2, id2);
            Assert.AreEqual(3, id3);
            Assert.AreEqual(4, id4);
        }