Core/Castle.Core.Tests/TraceLoggerTests.cs

   1 // Copyright 2004-2008 Castle Project - http://www.castleproject.org/
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 namespace Castle.Core.Logging.Tests
  16 {
  17         using System;
  18         using System.Collections.Generic;
  19         using System.Text;
  20         using System.Diagnostics;
  21
  22         using NUnit.Framework;
  23
  24         /// <summary>
  25         /// Tests the TraceLogger and TraceLoggerFactory classes
  26         /// </summary>
  27         [TestFixture]
  28         public class TraceLoggerTests
  29         {
  30                 [SetUp]
  31                 public void Initialize()
  32                 {
  33                         Listener.ClearMessages();
  34                 }
  35
  36                 [TearDown]
  37                 public void Cleanup()
  38                 {
  39                         Listener.ClearMessages();
  40                 }
  41
  42                 [Test]
  43                 public void WritingToLoggerByType()
  44                 {
  45                         TraceLoggerFactory factory = new TraceLoggerFactory();
  46                         ILogger logger = factory.Create(typeof(TraceLoggerTests), LoggerLevel.Debug);
  47                         logger.Debug("this is a tracing message");
  48
  49                         Listener.AssertContains("testsrule", "Castle.Core.Logging.Tests.TraceLoggerTests");
  50                         Listener.AssertContains("testsrule", "this is a tracing message");
  51                 }
  52
  53                 [Test]
  54                 public void TracingErrorInformation()
  55                 {
  56                         TraceLoggerFactory factory = new TraceLoggerFactory();
  57                         ILogger logger = factory.Create(typeof(TraceLoggerTests), LoggerLevel.Debug);
  58                         try
  59                         {
  60                                 try
  61                                 {
  62                                         string fakearg = "Thisisavalue";
  63                                         throw new ArgumentOutOfRangeException("fakearg", fakearg, "Thisisamessage" );
  64                                 }
  65                                 catch (Exception ex)
  66                                 {
  67                                         throw new ApplicationException("Inner error is " + ex.Message, ex);
  68                                 }
  69                         }
  70                         catch (Exception ex)
  71                         {
  72                                 logger.Error("Problem handled", ex);
  73                         }
  74
  75                         Listener.AssertContains("testsrule", "Castle.Core.Logging.Tests.TraceLoggerTests");
  76                         Listener.AssertContains("testsrule", "Problem handled");
  77                         Listener.AssertContains("testsrule", "ApplicationException");
  78                         Listener.AssertContains("testsrule", "Inner error is");
  79                         Listener.AssertContains("testsrule", "ArgumentOutOfRangeException");
  80                         Listener.AssertContains("testsrule", "fakearg");
  81                         Listener.AssertContains("testsrule", "Thisisavalue");
  82                         Listener.AssertContains("testsrule", "Thisisamessage");
  83                 }
  84
  85                 [Test]
  86                 public void FallUpToShorterSourceName()
  87                 {
  88                         TraceLoggerFactory factory = new TraceLoggerFactory();
  89                         ILogger logger = factory.Create(typeof(Castle.Core.Configuration.Xml.XmlConfigurationDeserializer), LoggerLevel.Debug);
  90                         logger.Info("Logging to config namespace");
  91
  92                         Listener.AssertContains("configrule", "Castle.Core.Configuration.Xml.XmlConfigurationDeserializer");
  93                         Listener.AssertContains("configrule", "Logging to config namespace");
  94                 }
  95
  96                 [Test]
  97                 public void FallUpToDefaultSource()
  98                 {
  99                         TraceLoggerFactory factory = new TraceLoggerFactory();
 100                         ILogger logger = factory.Create("System.Xml.XmlDocument", LoggerLevel.Debug);
 101                         logger.Info("Logging to non-configured namespace namespace");
 102
 103                         Listener.AssertContains("defaultrule", "System.Xml.XmlDocument");
 104                         Listener.AssertContains("defaultrule", "Logging to non-configured namespace namespace");
 105                 }
 106
 107                 #region in-memory listener class
 108
 109                 /// <summary>
 110                 /// This class captures trace text and records it to StringBuilders in a static dictionary.
 111                 /// Used for the sake of unit testing.
 112                 /// </summary>
 113                 public class Listener : TraceListener
 114                 {
 115                         public Listener()
 116                         {
 117                         }
 118
 119                         public Listener(string initializationData)
 120                         {
 121                                 traceName = initializationData;
 122                         }
 123
 124                         static Dictionary<string, StringBuilder> traces = new Dictionary<string, StringBuilder>();
 125                         readonly string traceName;
 126
 127                         StringBuilder GetStringBuilder()
 128                         {
 129                                 lock (traces)
 130                                 {
 131                                         if (!traces.ContainsKey(traceName))
 132                                                 traces.Add(traceName, new StringBuilder());
 133
 134                                         return traces[traceName];
 135                                 }
 136                         }
 137
 138                         public override void Write(string message)
 139                         {
 140                                 GetStringBuilder().Append(message);
 141                         }
 142
 143                         public override void WriteLine(string message)
 144                         {
 145                                 GetStringBuilder().AppendLine(message);
 146                         }
 147
 148                         public static void AssertContains(string traceName, string expected)
 149                         {
 150                                 Assert.IsTrue(traces.ContainsKey(traceName), "Trace named {0} not found", traceName);
 151                                 Assert.IsTrue(traces[traceName].ToString().Contains(expected), string.Format("Trace text expected to contain '{0}'", expected));
 152                         }
 153
 154                         public static void ClearMessages()
 155                         {
 156                                 traces = new Dictionary<string, StringBuilder>();
 157                         }
 158                 }
 159                 #endregion
 160         }
 161 }