MonoRail/Castle.MonoRail.Views.Brail.Tests/BrailBasicFunctionality.cs

   1 // Copyright 2004-2007 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.MonoRail.Views.Brail.Tests
  16 {
  17         using System;
  18         using System.IO;
  19         using System.Threading;
  20         using Castle.MonoRail.Framework.Tests;
  21         using NUnit.Framework;
  22
  23         [TestFixture]
  24         public class BrailBasicFunctionality : AbstractTestCase
  25         {
  26                 [Test]
  27                 public void AppPath()
  28                 {
  29                         DoGet("apppath/index.rails");
  30                         AssertReplyEqualTo("Current apppath is ");
  31                 }
  32
  33                 [Test]
  34                 public void CanUseUrlHelperWithoutPrefix()
  35                 {
  36                         DoGet("home/CanUseUrlHelperWithoutPrefix.rails");
  37                         AssertReplyEqualTo("Castle.MonoRail.Framework.Helpers.UrlHelper");
  38                 }
  39
  40                 [Test]
  41                 public void WithNullableDynamicProxyObject()
  42                 {
  43                         DoGet("home/WithNullableDynamicProxyObject.rails");
  44                         string expected = @"BarBaz
  45 foo
  46 what?
  47 there";
  48                         AssertReplyEqualTo(expected);
  49                 }
  50
  51                 [Test]
  52                 public void AppPathChangeOnTheFly()
  53                 {
  54                         string script = Path.Combine(GetPhysicalDir(), @"Views\AppPath\Index.brail");
  55                         string newContent = "new content";
  56                         string old;
  57                         using (TextReader read = File.OpenText(script))
  58                         {
  59                                 old = read.ReadToEnd();
  60                         }
  61             DoGet("apppath/index.rails");//init brail engine
  62                         using (TextWriter write = File.CreateText(script))
  63                         {
  64                                 write.Write(newContent);
  65                                 write.Flush();
  66                         }
  67                         Thread.Sleep(1000);
  68                         try
  69                         {
  70                                 DoGet("apppath/index.rails");
  71                                 AssertReplyEqualTo(newContent);
  72                         }
  73                         finally
  74                         {
  75                                 using (TextWriter write = File.CreateText(script))
  76                                 {
  77                                         write.Write(old);
  78                                 }
  79                         }
  80                 }
  81
  82                 [Test]
  83                 public void CommonScripts()
  84                 {
  85                         DoGet("home/nullables.rails");
  86                         string expected = "\r\nfoo";
  87                         AssertReplyEqualTo(expected);
  88                 }
  89
  90                 [Test]
  91                 public void Empty()
  92                 {
  93                         DoGet("home/Empty.rails");
  94                         string expected = "";
  95                         AssertReplyEqualTo(expected);
  96                 }
  97
  98                 [Test]
  99                 public void CommonScriptsChangeOnTheFly()
 100                 {
 101                         string common = Path.Combine(GetPhysicalDir(), @"Views\CommonScripts\Hello.brail");
 102                         string old;
 103                         using (TextReader read = File.OpenText(common))
 104                         {
 105                                 old = read.ReadToEnd();
 106                         }
 107                         string @new = @"
 108 def SayHello(name as string):
 109         return 'Hello, '+name+'! Modified!'
 110 end";
 111                         using (TextWriter write = File.CreateText(common))
 112                         {
 113                                 write.Write(@new);
 114                         }
 115                         string expected = "Hello, Ayende! Modified!";
 116                         // Have to wait for the common scripts recompilation otherwise you get random test failure since the request
 117                         // sometimes gets there faster you can recompile and it gets the old version.
 118                         Thread.Sleep(500);
 119                         try
 120                         {
 121                                 DoGet("home/hellofromcommon.rails");
 122                                 AssertReplyEqualTo(expected);
 123                         }
 124                         finally
 125                         {
 126                                 using (TextWriter write = File.CreateText(common))
 127                                 {
 128                                         write.Write(old);
 129                                 }
 130                         }
 131                         // Have to wait again to make sure that the second recompilation happened, since otherwise a second test
 132                         // might get the modified version.
 133                         Thread.Sleep(500);
 134                 }
 135
 136                 [Test]
 137                 public void LayoutsChangeOnTheFly()
 138                 {
 139                         string layout = Path.Combine(GetPhysicalDir(), @"Views\layouts\defaultlayout.brail");
 140                         string old;
 141                         using (TextReader read = File.OpenText(layout))
 142                         {
 143                                 old = read.ReadToEnd();
 144                         }
 145                         string newLayout = @"start modified
 146 ${ChildOutput}
 147 end";
 148                         using (TextWriter write = File.CreateText(layout))
 149                         {
 150                                 write.Write(newLayout);
 151                         }
 152                         string expected = @"start modified
 153 content
 154 end";
 155                         Thread.Sleep(500);
 156                         try
 157                         {
 158                                 DoGet("defaultlayout/index.rails");
 159                                 AssertReplyEqualTo(expected);
 160                         }
 161                         finally
 162                         {
 163                                 using (TextWriter write = File.CreateText(layout))
 164                                 {
 165                                         write.Write(old);
 166                                 }
 167                         }
 168                         Thread.Sleep(500);
 169                 }
 170
 171
 172                 [Test]
 173                 public void PreProcessor()
 174                 {
 175                         DoGet("home/preprocessor.rails");
 176                         string expected =
 177                                 @"
 178 <html>
 179 <body>
 180 <title>AYENDE</title>
 181 <body>
 182 <ul>
 183 <li>0</li><li>1</li><li>2</li>
 184 </ul>
 185 </body>
 186 </html>
 187 ";
 188                         AssertReplyEqualTo(expected);
 189                 }
 190
 191                 [Test]
 192                 public void CanUseNamespacesFromConfig()
 193                 {
 194                         string expected = "Using Udp without namespace, since it is in the web.config\r\n";
 195                         DoGet("home/namespacesInConfig.rails");
 196                         AssertReplyEqualTo(expected);
 197                 }
 198
 199                 [Test]
 200                 public void ComplexNestedExpressions()
 201                 {
 202                         string expected = "<a href=\"/customers/list.rails\" onclick=\"paginate(5)\" >first</a>";
 203                         DoGet("home/complexNestedExpressions.rails");
 204                         AssertReplyEqualTo(expected);
 205                 }
 206
 207                 [Test]
 208                 public void ComplexNestedExpressions2()
 209                 {
 210                         string expected = "<a onclick=\"alert(5)\"  href=\"/customers/list.rails?page=5\">first</a>";
 211                         DoGet("home/complexNestedExpressions2.rails");
 212                         AssertReplyEqualTo(expected);
 213                 }
 214
 215                 [Test]
 216                 public void Javascript()
 217                 {
 218                         string expected = @"<script type='text/javascript'>
 219         function paginate(index)
 220         {
 221                 alert(index);
 222         }
 223 </script>";;
 224                         DoGet("home/javascript.rails");
 225                         AssertReplyEqualTo(expected);
 226                 }
 227
 228                 [Test]
 229                 public void Javascript2()
 230                 {
 231                         string expected = @"<script type='text/javascript'>
 232         function paginate(index)
 233         {
 234                 var url = '/customers/list.rails';
 235                 var params = 'page='+index+'&isAjax=true';
 236                 new Ajax.Request(url, {
 237                         method: 'get',
 238                         evalScripts: true,
 239                         parameters: params
 240                         });
 241         }
 242 </script>";;
 243                         DoGet("home/javascript2.rails");
 244                         AssertReplyEqualTo(expected);
 245                 }
 246
 247                 [Test]
 248                 public void OutputSubViewInDiv()
 249                 {
 250                         string expected = @"<div>
 251 Contents for heyhello View
 252 </div>";
 253                         DoGet("home/subview.rails");
 254                         AssertReplyEqualTo(expected);
 255                 }
 256
 257                 [Test]
 258                 public void UsingQuotes()
 259                 {
 260                         string expected = "<script type=\"text/javascript\" language=\"javascript\" src=\"/Content/js/datepicker.js\"></script>";
 261                         DoGet("home/usingQuotes.rails");
 262                         AssertReplyEqualTo(expected);
 263                 }
 264
 265         [Test]
 266         public void DuckOverloadToString()
 267         {
 268             DoGet("home/DuckOverloadToString.rails");
 269             AssertReplyEqualTo("20-12-1981");
 270         }
 271
 272         [Test]
 273         public void NullPropagation()
 274         {
 275             DoGet("home/NullPropagation.rails");
 276             AssertReplyIsBlank();
 277         }
 278         }
 279 }