MonoRail/Castle.MonoRail.Framework.Tests/Helpers/FormHelperSetOperation.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.Framework.Tests.Helpers
  16 {
  17         using System.Globalization;
  18         using System.Threading;
  19
  20         using Castle.MonoRail.Framework.Helpers;
  21
  22         using NUnit.Framework;
  23
  24         [TestFixture]
  25         public class FormHelperSetOperation
  26         {
  27                 [SetUp]
  28                 public void Init()
  29                 {
  30                         CultureInfo en = CultureInfo.CreateSpecificCulture("en");
  31
  32                         Thread.CurrentThread.CurrentCulture     = en;
  33                         Thread.CurrentThread.CurrentUICulture = en;
  34                 }
  35
  36                 [Test]
  37                 public void EmptyInitialSet()
  38                 {
  39                         OperationState state = SetOperation.IterateOnDataSource(
  40                                 null, new int[] {1, 2, 3, 4}, null);
  41
  42                         Assert.IsNotNull(state);
  43                         Assert.IsTrue(state is ListDataSourceState);
  44                         Assert.IsNull(state.TargetSuffix);
  45
  46                         bool iterated = false;
  47                         int index = 1;
  48
  49                         foreach(SetItem item in state)
  50                         {
  51                                 iterated = true;
  52
  53                                 Assert.IsFalse(item.IsSelected);
  54                                 Assert.IsNotNull(item.Text);
  55                                 Assert.IsNotNull(item.Value);
  56
  57                                 Assert.AreEqual(index.ToString(), item.Text);
  58                                 Assert.AreEqual(index.ToString(), item.Value);
  59
  60                                 index++;
  61                         }
  62
  63                         Assert.IsTrue(iterated);
  64                 }
  65
  66                 [Test]
  67                 public void ApplyingFormat()
  68                 {
  69                         OperationState state = SetOperation.IterateOnDataSource(
  70                                 null, new int[] { 1, 2, 3, 4 }, DictHelper.Create("textformat=C"));
  71
  72                         Assert.IsNotNull(state);
  73                         Assert.IsTrue(state is ListDataSourceState);
  74                         Assert.IsNull(state.TargetSuffix);
  75
  76                         bool iterated = false;
  77                         int index = 1;
  78
  79                         foreach(SetItem item in state)
  80                         {
  81                                 iterated = true;
  82
  83                                 Assert.IsFalse(item.IsSelected);
  84                                 Assert.IsNotNull(item.Text);
  85                                 Assert.IsNotNull(item.Value);
  86
  87                                 Assert.AreEqual(index.ToString("C"), item.Text);
  88                                 Assert.AreEqual(index.ToString(), item.Value);
  89
  90                                 index++;
  91                         }
  92
  93                         Assert.IsTrue(iterated);
  94                 }
  95
  96
  97                 [Test]
  98                 public void NullDataSource()
  99                 {
 100                         OperationState state = SetOperation.IterateOnDataSource(
 101                                 new int[] {1, 2, 3, 4}, null, null);
 102
 103                         Assert.IsNotNull(state);
 104                         Assert.IsTrue(state is NoIterationState);
 105                         Assert.IsNull(state.TargetSuffix);
 106
 107                         Assert.IsFalse(state.MoveNext());
 108                 }
 109
 110                 [Test]
 111                 public void EmptyDataSource()
 112                 {
 113                         OperationState state = SetOperation.IterateOnDataSource(
 114                                 new int[] {1, 2, 3, 4}, new int[0], null);
 115
 116                         Assert.IsNotNull(state);
 117                         Assert.IsTrue(state is NoIterationState);
 118                         Assert.IsNull(state.TargetSuffix);
 119
 120                         Assert.IsFalse(state.MoveNext());
 121                 }
 122
 123                 [Test]
 124                 public void SingleValueInitialSet_SameTypes()
 125                 {
 126                         OperationState state = SetOperation.IterateOnDataSource(
 127                                 1, new int[] {1, 2, 3, 4}, null);
 128
 129                         Assert.IsNotNull(state);
 130                         Assert.IsTrue(state is SameTypeOperationState);
 131                         Assert.AreEqual("", state.TargetSuffix);
 132
 133                         bool iterated = false;
 134                         int index = 1;
 135
 136                         foreach(SetItem item in state)
 137                         {
 138                                 iterated = true;
 139
 140                                 if (index == 1)
 141                                 {
 142                                         Assert.IsTrue(item.IsSelected);
 143                                 }
 144                                 else
 145                                 {
 146                                         Assert.IsFalse(item.IsSelected);
 147                                 }
 148                                 Assert.IsNotNull(item.Text);
 149                                 Assert.IsNotNull(item.Value);
 150
 151                                 Assert.AreEqual(index.ToString(), item.Text);
 152                                 Assert.AreEqual(index.ToString(), item.Value);
 153
 154                                 index++;
 155                         }
 156
 157                         Assert.IsTrue(iterated);
 158                 }
 159
 160                 [Test]
 161                 public void MultipleValuesInitialSet_SameTypes()
 162                 {
 163                         OperationState state = SetOperation.IterateOnDataSource(
 164                                 new int[] {1,2}, new int[] {1, 2, 3, 4}, null);
 165
 166                         Assert.IsNotNull(state);
 167                         Assert.IsTrue(state is SameTypeOperationState);
 168                         Assert.AreEqual("", state.TargetSuffix);
 169
 170                         bool iterated = false;
 171                         int index = 1;
 172
 173                         foreach(SetItem item in state)
 174                         {
 175                                 iterated = true;
 176
 177                                 if (index == 1 || index == 2)
 178                                 {
 179                                         Assert.IsTrue(item.IsSelected);
 180                                 }
 181                                 else
 182                                 {
 183                                         Assert.IsFalse(item.IsSelected);
 184                                 }
 185                                 Assert.IsNotNull(item.Text);
 186                                 Assert.IsNotNull(item.Value);
 187
 188                                 Assert.AreEqual(index.ToString(), item.Text);
 189                                 Assert.AreEqual(index.ToString(), item.Value);
 190
 191                                 index++;
 192                         }
 193
 194                         Assert.IsTrue(iterated);
 195                 }
 196
 197                 [Test]
 198                 public void SingleValueInitialSet_SameTypes_NonPrimitive()
 199                 {
 200                         OperationState state = SetOperation.IterateOnDataSource(
 201                                 new Role(1, "Admin"), new Role[] {new Role(0,"User"), new Role(1,"Admin")},
 202                                 DictHelper.Create("text=Name", "value=Id"));
 203
 204                         Assert.IsNotNull(state);
 205                         Assert.IsTrue(state is SameTypeOperationState);
 206                         Assert.AreEqual("Id", state.TargetSuffix);
 207
 208                         bool iterated = false;
 209                         int index = 1;
 210
 211                         foreach(SetItem item in state)
 212                         {
 213                                 iterated = true;
 214
 215                                 Assert.IsNotNull(item.Text);
 216                                 Assert.IsNotNull(item.Value);
 217
 218                                 if (index == 1)
 219                                 {
 220                                         Assert.IsFalse(item.IsSelected);
 221                                         Assert.AreEqual("User", item.Text);
 222                                         Assert.AreEqual("0", item.Value);
 223                                 }
 224                                 else
 225                                 {
 226                                         Assert.IsTrue(item.IsSelected);
 227                                         Assert.AreEqual("Admin", item.Text);
 228                                         Assert.AreEqual("1", item.Value);
 229                                 }
 230
 231                                 index++;
 232                         }
 233
 234                         Assert.IsTrue(iterated);
 235                 }
 236
 237                 [Test]
 238                 public void MultipleValuesInitialSet_SameTypes_NonPrimitive()
 239                 {
 240                         OperationState state = SetOperation.IterateOnDataSource(
 241                                 new Role[] {new Role(0,"User"), new Role(1,"Admin")},
 242                                 new Role[] {new Role(0,"User"), new Role(1,"Admin")},
 243                                 DictHelper.Create("text=Name", "value=Id"));
 244
 245                         Assert.IsNotNull(state);
 246                         Assert.IsTrue(state is SameTypeOperationState);
 247                         Assert.AreEqual("Id", state.TargetSuffix);
 248
 249                         bool iterated = false;
 250                         int index = 1;
 251
 252                         foreach(SetItem item in state)
 253                         {
 254                                 iterated = true;
 255
 256                                 Assert.IsNotNull(item.Text);
 257                                 Assert.IsNotNull(item.Value);
 258                                 Assert.IsTrue(item.IsSelected);
 259
 260                                 if (index == 1)
 261                                 {
 262                                         Assert.AreEqual("User", item.Text);
 263                                         Assert.AreEqual("0", item.Value);
 264                                 }
 265                                 else
 266                                 {
 267                                         Assert.AreEqual("Admin", item.Text);
 268                                         Assert.AreEqual("1", item.Value);
 269                                 }
 270
 271                                 index++;
 272                         }
 273
 274                         Assert.IsTrue(iterated);
 275                 }
 276
 277                 [Test]
 278                 public void MultipleValuesInitialSet_DifferentTypes_NonPrimitive()
 279                 {
 280                         OperationState state = SetOperation.IterateOnDataSource(
 281                                 new ProductCategory[] {new ProductCategory(0,"User"), new ProductCategory(1,"Admin")},
 282                                 new Role[] {new Role(0,"User"), new Role(1,"Admin")},
 283                                 DictHelper.Create("text=Name", "value=Id"));
 284
 285                         Assert.IsNotNull(state);
 286                         Assert.IsTrue(state is DifferentTypeOperationState);
 287                         Assert.AreEqual("Id", state.TargetSuffix);
 288
 289                         bool iterated = false;
 290                         int index = 1;
 291
 292                         foreach(SetItem item in state)
 293                         {
 294                                 iterated = true;
 295
 296                                 Assert.IsNotNull(item.Text);
 297                                 Assert.IsNotNull(item.Value);
 298                                 Assert.IsTrue(item.IsSelected);
 299
 300                                 if (index == 1)
 301                                 {
 302                                         Assert.AreEqual("User", item.Text);
 303                                         Assert.AreEqual("0", item.Value);
 304                                 }
 305                                 else
 306                                 {
 307                                         Assert.AreEqual("Admin", item.Text);
 308                                         Assert.AreEqual("1", item.Value);
 309                                 }
 310
 311                                 index++;
 312                         }
 313
 314                         Assert.IsTrue(iterated);
 315                 }
 316
 317                 [Test]
 318                 public void SingleValueInitialSet_DifferentTypes_NonPrimitive_NoNameMatching()
 319                 {
 320                         OperationState state = SetOperation.IterateOnDataSource(
 321                                 new Role2(1,"Admin"),
 322                                 new Role[] {new Role(0,"User"), new Role(1,"Admin")},
 323                                 DictHelper.Create("text=Name", "value=Id", "sourceproperty=identification"));
 324
 325                         Assert.IsNotNull(state);
 326                         Assert.IsTrue(state is DifferentTypeOperationState);
 327                         Assert.AreEqual("Identification", state.TargetSuffix);
 328
 329                         bool iterated = false;
 330                         int index = 1;
 331
 332                         foreach(SetItem item in state)
 333                         {
 334                                 iterated = true;
 335
 336                                 Assert.IsNotNull(item.Text);
 337                                 Assert.IsNotNull(item.Value);
 338
 339                                 if (index == 1)
 340                                 {
 341                                         Assert.IsFalse(item.IsSelected);
 342                                         Assert.AreEqual("User", item.Text);
 343                                         Assert.AreEqual("0", item.Value);
 344                                 }
 345                                 else
 346                                 {
 347                                         Assert.IsTrue(item.IsSelected);
 348                                         Assert.AreEqual("Admin", item.Text);
 349                                         Assert.AreEqual("1", item.Value);
 350                                 }
 351
 352                                 index++;
 353                         }
 354
 355                         Assert.IsTrue(iterated);
 356                 }
 357
 358                 [Test]
 359                 public void MultipleValuesInitialSet_DifferentTypes_NonPrimitive_NoNameMatching()
 360                 {
 361                         OperationState state = SetOperation.IterateOnDataSource(
 362                                 new Role2[] {new Role2(0,"User"), new Role2(1,"Admin")},
 363                                 new Role[] {new Role(0,"User"), new Role(1,"Admin")},
 364                                 DictHelper.Create("text=Name", "value=Id", "sourceproperty=identification"));
 365
 366                         Assert.IsNotNull(state);
 367                         Assert.IsTrue(state is DifferentTypeOperationState);
 368                         Assert.AreEqual("Identification", state.TargetSuffix);
 369
 370                         bool iterated = false;
 371                         int index = 1;
 372
 373                         foreach(SetItem item in state)
 374                         {
 375                                 iterated = true;
 376
 377                                 Assert.IsNotNull(item.Text);
 378                                 Assert.IsNotNull(item.Value);
 379                                 Assert.IsTrue(item.IsSelected);
 380
 381                                 if (index == 1)
 382                                 {
 383                                         Assert.AreEqual("User", item.Text);
 384                                         Assert.AreEqual("0", item.Value);
 385                                 }
 386                                 else
 387                                 {
 388                                         Assert.AreEqual("Admin", item.Text);
 389                                         Assert.AreEqual("1", item.Value);
 390                                 }
 391
 392                                 index++;
 393                         }
 394
 395                         Assert.IsTrue(iterated);
 396                 }
 397
 398                 /// <summary>
 399                 /// The target is a decimal while the data source is an array of strings
 400                 /// </summary>
 401                 [Test]
 402                 public void SingleSelectionDifferentTypes()
 403                 {
 404                         CultureInfo en = CultureInfo.CreateSpecificCulture("pt-br");
 405
 406                         Thread.CurrentThread.CurrentCulture = en;
 407                         Thread.CurrentThread.CurrentUICulture = en;
 408
 409                         OperationState state = SetOperation.IterateOnDataSource(
 410                                 (decimal?) 1.5,
 411                                 new string[] { "1", "1,5", "2" }, null);
 412                         Assert.IsNotNull(state);
 413                         Assert.IsTrue(state is DifferentTypeOperationState);
 414
 415                         bool iterated = false;
 416                         int index = 0;
 417
 418                         foreach(SetItem item in state)
 419                         {
 420                                 iterated = true;
 421
 422                                 Assert.IsNotNull(item.Text);
 423                                 Assert.IsNotNull(item.Value);
 424
 425                                 if (index == 1)
 426                                 {
 427                                         Assert.IsTrue(item.IsSelected);
 428                                         Assert.AreEqual("1,5", item.Text);
 429                                         Assert.AreEqual("1,5", item.Value);
 430                                 }
 431                                 else
 432                                 {
 433                                         Assert.IsFalse(item.IsSelected);
 434                                 }
 435
 436                                 index++;
 437                         }
 438
 439                         Assert.IsTrue(iterated);
 440                 }
 441
 442                 [Test]
 443                 public void MultipleValuesInitialSet_DifferentTypes_Primitive_NoNameMatching()
 444                 {
 445                         OperationState state = SetOperation.IterateOnDataSource(
 446                                 new int[] {0,1},
 447                                 new Role[] {new Role(0,"User"), new Role(1,"Admin")},
 448                                 DictHelper.Create("text=Name", "value=Id"));
 449
 450                         Assert.IsNotNull(state);
 451                         Assert.IsTrue(state is DifferentTypeOperationState);
 452                         Assert.AreEqual("", state.TargetSuffix);
 453
 454                         bool iterated = false;
 455                         int index = 1;
 456
 457                         foreach(SetItem item in state)
 458                         {
 459                                 iterated = true;
 460
 461                                 Assert.IsNotNull(item.Text);
 462                                 Assert.IsNotNull(item.Value);
 463                                 Assert.IsTrue(item.IsSelected);
 464
 465                                 if (index == 1)
 466                                 {
 467                                         Assert.AreEqual("User", item.Text);
 468                                         Assert.AreEqual("0", item.Value);
 469                                 }
 470                                 else
 471                                 {
 472                                         Assert.AreEqual("Admin", item.Text);
 473                                         Assert.AreEqual("1", item.Value);
 474                                 }
 475
 476                                 index++;
 477                         }
 478
 479                         Assert.IsTrue(iterated);
 480                 }
 481         }
 482 }