mcs/class/System.Web/Test/System.Web.Compilation/RouteUrlExpressionBuilderTest.cs

   1 //
   2 // RouteUrlExpressionBuilder.cs
   3 //
   4 // Authors:
   5 //      Marek Habersack <mhabersack@novell.com>
   6 //
   7 // Copyright (C) 2010 Novell, Inc. (http://novell.com/)
   8 //
   9 // Permission is hereby granted, free of charge, to any person obtaining
  10 // a copy of this software and associated documentation files (the
  11 // "Software"), to deal in the Software without restriction, including
  12 // without limitation the rights to use, copy, modify, merge, publish,
  13 // distribute, sublicense, and/or sell copies of the Software, and to
  14 // permit persons to whom the Software is furnished to do so, subject to
  15 // the following conditions:
  16 //
  17 // The above copyright notice and this permission notice shall be
  18 // included in all copies or substantial portions of the Software.
  19 //
  20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  23 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  24 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  25 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  26 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27 //
  28 using System;
  29 using System.CodeDom;
  30 using System.IO;
  31 using System.Reflection;
  32 using System.Web;
  33 using System.Web.Compilation;
  34 using System.Web.UI;
  35 using System.Web.UI.WebControls;
  36 using System.Web.Routing;
  37
  38 using NUnit.Framework;
  39
  40 using MonoTests.SystemWeb.Framework;
  41 using MonoTests.stand_alone.WebHarness;
  42 using MonoTests.Common;
  43
  44 namespace MonoTests.System.Web.Compilation
  45 {
  46         [TestFixture]
  47         public class RouteUrlExpressionBuilderTest
  48         {
  49                 [Test]
  50                 public void EvaluateExpression ()
  51                 {
  52                         RouteTable.Routes.Clear ();
  53                         RouteTable.Routes.Add (new Route ("{foo}-foo", new PageRouteHandler ("~/default.aspx")));
  54                         RouteTable.Routes.Add ("bar1", new Route ("{bar}-foo", new PageRouteHandler ("~/bar.aspx")));
  55                         RouteTable.Routes.Add ("bar2", new Route ("some-{bar}", new PageRouteHandler ("~/some-bar.aspx")));
  56
  57                         var bldr = new RouteUrlExpressionBuilder ();
  58                         var entry = CreatePropertyEntry ("foo=test", "RouteUrl");
  59                         var context = new ExpressionBuilderContext (new FakePage ());
  60                         object obj = bldr.EvaluateExpression (null, entry, null, context);
  61                         Assert.AreEqual ("/test-foo", obj, "#A1");
  62
  63                         entry = CreatePropertyEntry ("bar=test", "RouteUrl");
  64                         obj = bldr.EvaluateExpression (null, entry, null, context);
  65                         Assert.AreEqual ("/test-foo", obj, "#A2-1");
  66
  67                         entry = CreatePropertyEntry ("bar=test,routename=bar2", "RouteUrl");
  68                         obj = bldr.EvaluateExpression (null, entry, null, context);
  69                         Assert.AreEqual ("/some-test", obj, "#A2-2");
  70
  71                         entry = CreatePropertyEntry ("bar=test,routename=bar1", "RouteUrl");
  72                         obj = bldr.EvaluateExpression (null, entry, null, context);
  73                         Assert.AreEqual ("/test-foo", obj, "#A2-3");
  74
  75                         entry = CreatePropertyEntry ("bar=test,routename=noroute", "RouteUrl");
  76                         try {
  77                                 obj = bldr.EvaluateExpression (null, entry, null, context);
  78                                 Assert.Fail ("#A3");
  79                         } catch (ArgumentException) {
  80                                 // success
  81                         }
  82
  83                         entry = CreatePropertyEntry ("nosuchparam=test", "RouteUrl");
  84                         obj = bldr.EvaluateExpression (null, entry, null, context);
  85                         Assert.IsNull (obj, "#A4");
  86
  87                         AssertExtensions.Throws<NullReferenceException> (() => {
  88                                 bldr.EvaluateExpression (null, null, null, context);
  89                         }, "#A5-1");
  90
  91                         AssertExtensions.Throws<NullReferenceException> (() => {
  92                                 bldr.EvaluateExpression (null, entry, null, null);
  93                         }, "#A5-2");
  94                 }
  95
  96                 BoundPropertyEntry CreatePropertyEntry (string expression, string expressionPrefix)
  97                 {
  98                         var entry = Activator.CreateInstance (typeof (BoundPropertyEntry), true) as BoundPropertyEntry;
  99                         entry.Expression = expression;
 100                         entry.ExpressionPrefix = expressionPrefix;
 101
 102                         return entry;
 103                 }
 104
 105                 [Test]
 106                 public void GetRouteUrl ()
 107                 {
 108                         AssertExtensions.Throws<ArgumentNullException> (() => {
 109                                 RouteUrlExpressionBuilder.GetRouteUrl (null, "bar=test");
 110                         }, "#A1-1");
 111
 112                         var t = new WebTest (PageInvoker.CreateOnLoad (GetRouteUrl_Load));
 113                         t.Run ();
 114                 }
 115
 116                 public static void GetRouteUrl_Load (Page p)
 117                 {
 118                         RouteTable.Routes.Clear ();
 119                         RouteTable.Routes.Add (new Route ("{foo}-foo", new PageRouteHandler ("~/default.aspx")));
 120                         RouteTable.Routes.Add ("bar1", new Route ("{bar}-foo", new PageRouteHandler ("~/bar.aspx")));
 121
 122                         var ctl = new Control ();
 123                         string url = RouteUrlExpressionBuilder.GetRouteUrl (new Control (), "foobar=test");
 124                         Assert.IsNull (url, "#A2");
 125
 126                         url = RouteUrlExpressionBuilder.GetRouteUrl (new Control (), "bar=test");
 127                         Assert.IsNotNull (url, "#A3-1");
 128                         Assert.AreEqual ("/NunitWeb/test-foo", url, "#A3-2");
 129
 130                         url = RouteUrlExpressionBuilder.GetRouteUrl (new Control (), "routename=bar1,bar=test");
 131                         Assert.IsNotNull (url, "#A4-1");
 132                         Assert.AreEqual ("/NunitWeb/test-foo", url, "#A4-2");
 133
 134                         url = RouteUrlExpressionBuilder.GetRouteUrl (new Control (), "ROUTEname=bar1,bar=test");
 135                         Assert.IsNotNull (url, "#A5-1");
 136                         Assert.AreEqual ("/NunitWeb/test-foo", url, "#A5-2");
 137
 138                         url = RouteUrlExpressionBuilder.GetRouteUrl (new Control (), "   routename  =   bar1,    bar  =    test     ");
 139                         Assert.IsNotNull (url, "#A6-1");
 140                         Assert.AreEqual ("/NunitWeb/test-foo", url, "#A6-2");
 141
 142                         AssertExtensions.Throws<InvalidOperationException> (() => {
 143                                 url = RouteUrlExpressionBuilder.GetRouteUrl (new Control (), "routename");
 144                         }, "#A7-1");
 145
 146                         AssertExtensions.Throws<InvalidOperationException> (() => {
 147                                 url = RouteUrlExpressionBuilder.GetRouteUrl (new Control (), String.Empty);
 148                         }, "#A7-2");
 149
 150                         AssertExtensions.Throws<InvalidOperationException> (() => {
 151                                 url = RouteUrlExpressionBuilder.GetRouteUrl (new Control (), null);
 152                         }, "#A7-2");
 153                 }
 154
 155                 [Test]
 156                 public void TryParseRouteExpression ()
 157                 {
 158                         string routeName;
 159                         var rvd = new RouteValueDictionary ();
 160
 161                         Assert.IsFalse (RouteUrlExpressionBuilder.TryParseRouteExpression (null, rvd, out routeName), "#A1-1");
 162                         Assert.IsFalse (RouteUrlExpressionBuilder.TryParseRouteExpression (String.Empty, rvd, out routeName), "#A1-2");
 163                         Assert.IsFalse (RouteUrlExpressionBuilder.TryParseRouteExpression ("route", rvd, out routeName), "#A1-3");
 164                         Assert.IsTrue (RouteUrlExpressionBuilder.TryParseRouteExpression ("route=", rvd, out routeName), "#A1-4");
 165                         Assert.AreEqual (1, rvd.Count, "#A1-4-1");
 166                         Assert.AreEqual (String.Empty, rvd ["route"], "#A1-4-2");
 167
 168                         AssertExtensions.Throws<NullReferenceException> (() => {
 169                                 RouteUrlExpressionBuilder.TryParseRouteExpression ("foo=bar", null, out routeName);
 170                         }, "#A1-5");
 171
 172                         rvd.Clear ();
 173                         Assert.IsTrue (RouteUrlExpressionBuilder.TryParseRouteExpression ("foo=bar", rvd, out routeName), "#A2-1");
 174                         Assert.AreEqual (1, rvd.Count, "#A2-2");
 175                         Assert.AreEqual ("bar", rvd ["foo"], "#A2-3");
 176                         Assert.IsNull (routeName, "#A2-4");
 177
 178                         rvd.Clear ();
 179                         Assert.IsTrue (RouteUrlExpressionBuilder.TryParseRouteExpression ("routeName=route,foo=bar,baz=zonk", rvd, out routeName), "#A3-1");
 180                         Assert.AreEqual (2, rvd.Count, "#A3-2");
 181                         Assert.AreEqual ("bar", rvd ["foo"], "#A3-3");
 182                         Assert.AreEqual ("zonk", rvd ["baz"], "#A3-3");
 183                         Assert.IsNotNull (routeName, "#A3-5");
 184                         Assert.AreEqual ("route", routeName, "#A3-6");
 185
 186                         rvd.Clear ();
 187                         Assert.IsTrue (RouteUrlExpressionBuilder.TryParseRouteExpression ("  rOUteName=route      ,  foo=bar\t,   baz   =\t  zonk   \t ", rvd, out routeName), "#A4-1");
 188                         Assert.AreEqual (2, rvd.Count, "#A4-2");
 189                         Assert.AreEqual ("bar", rvd ["foo"], "#A4-3");
 190                         Assert.AreEqual ("zonk", rvd ["baz"], "#A4-3");
 191                         Assert.IsNotNull (routeName, "#A4-5");
 192                         Assert.AreEqual ("route", routeName, "#A4-6");
 193
 194                         rvd.Clear ();
 195                         Assert.IsFalse (RouteUrlExpressionBuilder.TryParseRouteExpression ("foo=bar,route,baz=zonk", rvd, out routeName), "#A5-1");
 196                         Assert.AreEqual (1, rvd.Count, "#A5-2");
 197                         Assert.AreEqual ("bar", rvd ["foo"], "#A5-3");
 198
 199                         rvd.Clear ();
 200                         Assert.IsFalse (RouteUrlExpressionBuilder.TryParseRouteExpression ("foo=bar,route==,baz=zonk", rvd, out routeName), "#A6-1");
 201                         Assert.AreEqual (1, rvd.Count, "#A6-2");
 202                         Assert.AreEqual ("bar", rvd ["foo"], "#A6-3");
 203
 204                         rvd.Clear ();
 205                         Assert.IsFalse (RouteUrlExpressionBuilder.TryParseRouteExpression ("route==", rvd, out routeName), "#A7-1");
 206                         Assert.AreEqual (0, rvd.Count, "#A7-2");
 207
 208                         rvd.Clear ();
 209                         Assert.IsFalse (RouteUrlExpressionBuilder.TryParseRouteExpression ("route==stuff", rvd, out routeName), "#A8-1");
 210                         Assert.AreEqual (0, rvd.Count, "#A8-2");
 211
 212                         rvd.Clear ();
 213                         Assert.IsTrue (RouteUrlExpressionBuilder.TryParseRouteExpression ("route=stuff1,route=stuff2", rvd, out routeName), "#A9-1");
 214                         Assert.AreEqual (1, rvd.Count, "#A9-2");
 215                         Assert.AreEqual ("stuff2", rvd ["route"], "#A9-3");
 216
 217                         rvd.Clear ();
 218                         Assert.IsFalse (RouteUrlExpressionBuilder.TryParseRouteExpression ("=stuff", rvd, out routeName), "#A10-1");
 219                         Assert.AreEqual (0, rvd.Count, "#A10-2");
 220
 221                         rvd.Clear ();
 222                         Assert.IsTrue (RouteUrlExpressionBuilder.TryParseRouteExpression ("routeName=route,routename=route2,foo=bar,baz=zonk", rvd, out routeName), "#A11-1");
 223                         Assert.AreEqual (2, rvd.Count, "#A11-2");
 224                         Assert.AreEqual ("bar", rvd ["foo"], "#A11-3");
 225                         Assert.AreEqual ("zonk", rvd ["baz"], "#A11-3");
 226                         Assert.IsNotNull (routeName, "#A11-5");
 227                         Assert.AreEqual ("route2", routeName, "#A11-6");
 228                 }
 229
 230                 [Test]
 231                 public void GetCodeExpression ()
 232                 {
 233                         var bldr = new RouteUrlExpressionBuilder ();
 234                         var entry = CreatePropertyEntry ("foo=test", "RouteUrl");
 235                         var context = new ExpressionBuilderContext (new FakePage ());
 236                         CodeExpression expr;
 237
 238                         AssertExtensions.Throws<NullReferenceException> (() => {
 239                                 expr = bldr.GetCodeExpression (null, "data", context);
 240                         }, "#A1-1");
 241
 242                         expr = bldr.GetCodeExpression (entry, null, context);
 243                         Assert.IsNotNull (expr, "#A2");
 244
 245                         expr = bldr.GetCodeExpression (entry, "data", null);
 246                         Assert.IsNotNull (expr, "#A3");
 247
 248                         expr = bldr.GetCodeExpression (entry, null, null);
 249                         Assert.IsNotNull (expr, "#A4-1");
 250                         Assert.AreEqual (typeof (CodeMethodInvokeExpression), expr.GetType (), "#A4-2");
 251
 252                         var invoke = expr as CodeMethodInvokeExpression;
 253                         Assert.AreEqual (typeof (CodeTypeReferenceExpression), invoke.Method.TargetObject.GetType (), "#A4-3");
 254
 255                         var tref = invoke.Method.TargetObject as CodeTypeReferenceExpression;
 256                         Assert.AreEqual ("System.Web.Compilation.RouteUrlExpressionBuilder", tref.Type.BaseType, "#A4-4");
 257                         Assert.AreEqual ("GetRouteUrl", invoke.Method.MethodName, "#A4-5");
 258
 259                         Assert.AreEqual (2, invoke.Parameters.Count, "#A5-1");
 260                         Assert.AreEqual (typeof (CodeThisReferenceExpression), invoke.Parameters [0].GetType (), "#A5-2");
 261                         Assert.AreEqual (typeof (CodePrimitiveExpression), invoke.Parameters [1].GetType (), "#A5-3");
 262
 263                         var pex = invoke.Parameters [1] as CodePrimitiveExpression;
 264                         Assert.AreEqual ("foo=test", pex.Value, "#A5-4");
 265                 }
 266         }
 267
 268         class FakePage : Page
 269         {
 270                 private HttpContext ctx;
 271
 272                 // don't call base class (so _context is never set to a non-null value)
 273                 protected internal override HttpContext Context
 274                 {
 275                         get
 276                         {
 277                                 if (ctx == null) {
 278                                         ctx = new HttpContext (
 279                                                 new HttpRequest ("default.aspx", "http://mono-project.com/", "q=1&q2=2"),
 280                                                 new HttpResponse (new StringWriter ())
 281                                                 );
 282                                 }
 283                                 return ctx;
 284                         }
 285                 }
 286         }
 287 }