Facilities/Cache/Castle.Facilities.Cache.Tests/CacheTest.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 using System.Threading;
  16
  17 namespace Castle.Facilities.Cache.Tests
  18 {
  19         using System;
  20         using System.IO;
  21
  22         using Castle.Facilities.Cache.Manager;
  23         using Castle.Windsor;
  24
  25         using NUnit.Framework;
  26
  27         /// <summary>
  28         /// Summary description for Class1.
  29         /// </summary>
  30         [TestFixture]
  31         public class CacheTest
  32         {
  33                 private StringWriter _outWriter = new StringWriter();
  34                 private IWindsorContainer _container = null;
  35
  36                 [SetUp]
  37                 public void SetUp()
  38                 {
  39                         _container = new WindsorContainer(ConfigHelper.ResolvePath("../Castle.Facilities.Cache.Tests.config"));
  40                         _container.AddComponent("ServiceA",typeof(IServiceA), typeof(ServiceA));
  41                         _container.AddComponent("ServiceC",typeof(IServiceC), typeof(ServiceC));
  42                         _container.AddComponent("ServiceD",typeof(IServiceD), typeof(ServiceD));
  43
  44                         ResetConsoleOut();
  45                 }
  46
  47                 [TestFixtureTearDown]
  48                 public void TearDown()
  49                 {
  50                         _container.Dispose();
  51                 }
  52
  53                 public void ResetConsoleOut()
  54                 {
  55                         _outWriter = new StringWriter();
  56                         Console.SetOut(_outWriter);
  57                 }
  58
  59                 [Test]
  60                 public void TestCacheViaCode()
  61                 {
  62                         IServiceA serviceA = _container[typeof(IServiceA)] as IServiceA;
  63
  64                         serviceA.MyMethod(2, 5.5M);
  65                         string consoleContents = _outWriter.GetStringBuilder().ToString();
  66
  67                         serviceA.MyMethodNotcached("Gilles");
  68
  69                         serviceA.MyMethod(2, 5.5M);
  70                         Assert.AreEqual(consoleContents, _outWriter.GetStringBuilder().ToString() );
  71                 }
  72
  73                 [Test]
  74                 public void TestMultipleCacheViaCode()
  75                 {
  76                         IServiceD serviceD = _container[typeof(IServiceD)] as IServiceD;
  77
  78                         // MethodeA
  79                         FifoCacheManager fifoCacheManager = _container["Another.Cache"] as FifoCacheManager;
  80                         Assert.IsTrue(fifoCacheManager.KeyList.Count==0);
  81
  82                         serviceD.MyMethodA(2, 5);
  83                         string consoleContents = _outWriter.GetStringBuilder().ToString();
  84                         Assert.IsTrue(fifoCacheManager.KeyList.Count==1);
  85
  86                         serviceD.MyMethodA(2, 5);
  87                         Assert.AreEqual(consoleContents, _outWriter.GetStringBuilder().ToString() );
  88
  89                         serviceD.MyMethodA(3, 5);
  90                         Assert.IsFalse(consoleContents == _outWriter.GetStringBuilder().ToString() );
  91
  92                         // MethodeB
  93                         ResetConsoleOut();
  94
  95                         serviceD.MyMethodB( "Castle" );
  96                         consoleContents = _outWriter.GetStringBuilder().ToString();
  97
  98                         serviceD.MyMethodB( "Castle" );
  99                         Assert.AreEqual(consoleContents, _outWriter.GetStringBuilder().ToString() );
 100
 101                         serviceD.MyMethodB( "iBATIS" );
 102                         Assert.IsFalse(consoleContents == _outWriter.GetStringBuilder().ToString() );
 103                 }
 104
 105                 [Test]
 106                 public void TestCacheViaConfig()
 107                 {
 108                         IServiceB serviceB= _container[typeof(IServiceB)] as IServiceB;
 109
 110                         // MethodeA
 111                         FifoCacheManager fifoCacheManager = _container["Another.Cache"] as FifoCacheManager;
 112                         Assert.IsTrue(fifoCacheManager.KeyList.Count==0);
 113
 114                         serviceB.MyMethodA("cache", "serviceB", "MyMethodA");
 115                         string consoleContents = _outWriter.GetStringBuilder().ToString();
 116                         Assert.IsTrue(fifoCacheManager.KeyList.Count==1);
 117
 118                         serviceB.MyMethodA("cache", "serviceB", "MyMethodA");
 119                         Assert.AreEqual(consoleContents, _outWriter.GetStringBuilder().ToString() );
 120
 121                         // MethodeB
 122                         ResetConsoleOut();
 123
 124                         serviceB.MyMethodB();
 125                         consoleContents = _outWriter.GetStringBuilder().ToString();
 126
 127                         serviceB.MyMethodB();
 128                         Assert.AreEqual(consoleContents, _outWriter.GetStringBuilder().ToString() );
 129                 }
 130
 131                 [Test]
 132                 public void TestFicoCache()
 133                 {
 134                         IServiceA serviceA = _container[typeof(IServiceA)] as IServiceA;
 135                         IServiceC serviceC = _container[typeof(IServiceC)] as IServiceC;
 136
 137                         serviceA.MyMethod(2, 5.5M);
 138                         string consoleContents = _outWriter.GetStringBuilder().ToString();
 139
 140                         serviceC.MyMethod(2, 5.5M);
 141
 142                         ResetConsoleOut();
 143
 144                     Thread.Sleep(10);
 145
 146                         serviceA.MyMethod(2, 5.5M);
 147                         Assert.AreNotEqual( consoleContents , _outWriter.GetStringBuilder().ToString() );
 148                 }
 149         }
 150 }