Core/Castle.Core.Tests/StreamLoggerTests.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.IO;
  19         using System.Text.RegularExpressions;
  20
  21         using NUnit.Framework;
  22
  23         [TestFixture]
  24         public class StreamLoggerTests
  25         {
  26                 private const string Name = "Test";
  27
  28                 private StreamLogger logger;
  29                 private MemoryStream stream;
  30
  31                 [SetUp]
  32                 public void SetUp()
  33                 {
  34                         stream = new MemoryStream();
  35
  36                         logger = new StreamLogger(Name, stream);
  37                         logger.Level = LoggerLevel.Debug;
  38                 }
  39
  40
  41                 [Test]
  42                 public void Debug()
  43                 {
  44                         string message = "Debug message";
  45                         LoggerLevel level = LoggerLevel.Debug;
  46                         Exception exception = null;
  47
  48                         logger.Debug(message);
  49
  50                         ValidateCall(level, message, exception);
  51                 }
  52
  53                 [Test]
  54                 public void DebugWithException()
  55                 {
  56                         string message = "Debug message 2";
  57                         LoggerLevel level = LoggerLevel.Debug;
  58                         Exception exception = new Exception();
  59
  60                         logger.Debug(message, exception);
  61
  62                         ValidateCall(level, message, exception);
  63                 }
  64
  65                 [Test]
  66                 public void Info()
  67                 {
  68                         string message = "Info message";
  69                         LoggerLevel level = LoggerLevel.Info;
  70                         Exception exception = null;
  71
  72                         logger.Info(message);
  73
  74                         ValidateCall(level, message, exception);
  75                 }
  76
  77                 [Test]
  78                 public void InfoWithException()
  79                 {
  80                         string message = "Info message 2";
  81                         LoggerLevel level = LoggerLevel.Info;
  82                         Exception exception = new Exception();
  83
  84                         logger.Info(message, exception);
  85
  86                         ValidateCall(level, message, exception);
  87                 }
  88
  89                 [Test]
  90                 public void Warn()
  91                 {
  92                         string message = "Warn message";
  93                         LoggerLevel level = LoggerLevel.Warn;
  94                         Exception exception = null;
  95
  96                         logger.Warn(message);
  97
  98                         ValidateCall(level, message, exception);
  99                 }
 100
 101                 [Test]
 102                 public void WarnWithException()
 103                 {
 104                         string message = "Warn message 2";
 105                         LoggerLevel level = LoggerLevel.Warn;
 106                         Exception exception = new Exception();
 107
 108                         logger.Warn(message, exception);
 109
 110                         ValidateCall(level, message, exception);
 111                 }
 112
 113                 [Test]
 114                 public void Error()
 115                 {
 116                         string message = "Error message";
 117                         LoggerLevel level = LoggerLevel.Error;
 118                         Exception exception = null;
 119
 120                         logger.Error(message);
 121
 122                         ValidateCall(level, message, exception);
 123                 }
 124
 125                 [Test]
 126                 public void ErrorWithException()
 127                 {
 128                         string message = "Error message 2";
 129                         LoggerLevel level = LoggerLevel.Error;
 130                         Exception exception = new Exception();
 131
 132                         logger.Error(message, exception);
 133
 134                         ValidateCall(level, message, exception);
 135                 }
 136
 137                 [Test]
 138                 public void FatalError()
 139                 {
 140                         string message = "FatalError message";
 141                         LoggerLevel level = LoggerLevel.Fatal;
 142                         Exception exception = null;
 143
 144                         logger.Fatal(message);
 145
 146                         ValidateCall(level, message, exception);
 147                 }
 148
 149                 [Test]
 150                 public void FatalErrorWithException()
 151                 {
 152                         string message = "FatalError message 2";
 153                         LoggerLevel level = LoggerLevel.Fatal;
 154                         Exception exception = new Exception();
 155
 156                         logger.Fatal(message, exception);
 157
 158                         ValidateCall(level, message, exception);
 159                 }
 160
 161                 private void ValidateCall(LoggerLevel level, String expectedMessage, Exception expectedException)
 162                 {
 163                         stream.Seek(0, SeekOrigin.Begin);
 164
 165                         StreamReader reader = new StreamReader(stream);
 166                         String line = reader.ReadLine();
 167
 168                         Match match = Regex.Match(line, @"^\[(?<level>[^]]+)\] '(?<name>[^']+)' (?<message>.*)$");
 169
 170                         Assert.IsTrue(match.Success, "StreamLogger.Log did not match the format");
 171                         Assert.AreEqual(Name, match.Groups["name"].Value, "StreamLogger.Log did not write the correct Name");
 172                         Assert.AreEqual(level.ToString(), match.Groups["level"].Value, "StreamLogger.Log did not write the correct Level");
 173                         Assert.AreEqual(expectedMessage, match.Groups["message"].Value, "StreamLogger.Log did not write the correct Message");
 174
 175                         line = reader.ReadLine();
 176
 177                         if (expectedException == null)
 178                         {
 179                                 Assert.IsNull(line);
 180                         }
 181                         else
 182                         {
 183                                 match = Regex.Match(line, @"^\[(?<level>[^]]+)\] '(?<name>[^']+)' (?<type>[^:]+): (?<message>.*)$");
 184
 185                                 Assert.IsTrue(match.Success, "StreamLogger.Log did not match the format");
 186                                 Assert.AreEqual(Name, match.Groups["name"].Value, "StreamLogger.Log did not write the correct Name");
 187                                 Assert.AreEqual(level.ToString(), match.Groups["level"].Value, "StreamLogger.Log did not write the correct Level");
 188                                 Assert.AreEqual(expectedException.GetType().FullName, match.Groups["type"].Value, "StreamLogger.Log did not write the correct Exception Type");
 189                                 // Assert.AreEqual(expectedException.Message, match.Groups["message"].Value, "StreamLogger.Log did not write the correct Exception Message");
 190                         }
 191                 }
 192         }
 193 }