MonoRail/Castle.MonoRail.Framework.Tests/Helpers/FormHelperSetOperation.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.MonoRail.Framework.Tests.Helpers
  16 {
  17         using System.Globalization;
  18         using System.IO;
  19         using System.Threading;
  20         using Castle.MonoRail.Framework.Helpers;
  21         using Core;
  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_EnumPairs()
 125                 {
 126                         OperationState state = SetOperation.IterateOnDataSource(
 127                                 FileMode.Append, new Pair<FileMode, string>[]
 128                                                         {
 129                                                                 new Pair<FileMode, string>(FileMode.Append, "append"),
 130                                                                 new Pair<FileMode, string>(FileMode.Create, "create"),
 131                                                                 new Pair<FileMode, string>(FileMode.CreateNew, "new"),
 132                                                                 new Pair<FileMode, string>(FileMode.Open, "open")
 133                                                         }, DictHelper.Create("value=First", "text=Second"));
 134
 135                         Assert.IsNotNull(state);
 136                         Assert.IsTrue(state is DifferentTypeOperationState);
 137                         Assert.AreEqual("", state.TargetSuffix);
 138
 139                         bool iterated = false;
 140                         int index = 1;
 141
 142                         foreach(SetItem item in state)
 143                         {
 144                                 iterated = true;
 145
 146                                 if (index == 1)
 147                                 {
 148                                         Assert.IsTrue(item.IsSelected);
 149                                 }
 150                                 else
 151                                 {
 152                                         Assert.IsFalse(item.IsSelected);
 153                                 }
 154                                 Assert.IsNotNull(item.Text);
 155                                 Assert.IsNotNull(item.Value);
 156
 157                                 index++;
 158                         }
 159
 160                         Assert.IsTrue(iterated);
 161                 }
 162
 163                 [Test]
 164                 public void SingleValueInitialSet_SameTypes()
 165                 {
 166                         OperationState state = SetOperation.IterateOnDataSource(
 167                                 1, new int[] {1, 2, 3, 4}, null);
 168
 169                         Assert.IsNotNull(state);
 170                         Assert.IsTrue(state is SameTypeOperationState);
 171                         Assert.AreEqual("", state.TargetSuffix);
 172
 173                         bool iterated = false;
 174                         int index = 1;
 175
 176                         foreach (SetItem item in state)
 177                         {
 178                                 iterated = true;
 179
 180                                 if (index == 1)
 181                                 {
 182                                         Assert.IsTrue(item.IsSelected);
 183                                 }
 184                                 else
 185                                 {
 186                                         Assert.IsFalse(item.IsSelected);
 187                                 }
 188                                 Assert.IsNotNull(item.Text);
 189                                 Assert.IsNotNull(item.Value);
 190
 191                                 Assert.AreEqual(index.ToString(), item.Text);
 192                                 Assert.AreEqual(index.ToString(), item.Value);
 193
 194                                 index++;
 195                         }
 196
 197                         Assert.IsTrue(iterated);
 198                 }
 199
 200                 [Test]
 201                 public void MultipleValuesInitialSet_SameTypes()
 202                 {
 203                         OperationState state = SetOperation.IterateOnDataSource(
 204                                 new int[] {1, 2}, new int[] {1, 2, 3, 4}, null);
 205
 206                         Assert.IsNotNull(state);
 207                         Assert.IsTrue(state is SameTypeOperationState);
 208                         Assert.AreEqual("", state.TargetSuffix);
 209
 210                         bool iterated = false;
 211                         int index = 1;
 212
 213                         foreach (SetItem item in state)
 214                         {
 215                                 iterated = true;
 216
 217                                 if (index == 1 || index == 2)
 218                                 {
 219                                         Assert.IsTrue(item.IsSelected);
 220                                 }
 221                                 else
 222                                 {
 223                                         Assert.IsFalse(item.IsSelected);
 224                                 }
 225                                 Assert.IsNotNull(item.Text);
 226                                 Assert.IsNotNull(item.Value);
 227
 228                                 Assert.AreEqual(index.ToString(), item.Text);
 229                                 Assert.AreEqual(index.ToString(), item.Value);
 230
 231                                 index++;
 232                         }
 233
 234                         Assert.IsTrue(iterated);
 235                 }
 236
 237                 [Test]
 238                 public void SingleValueInitialSet_SameTypes_NonPrimitive()
 239                 {
 240                         OperationState state = SetOperation.IterateOnDataSource(
 241                                 new Role(1, "Admin"), new Role[] {new Role(0, "User"), new Role(1, "Admin")},
 242                                 DictHelper.Create("text=Name", "value=Id"));
 243
 244                         Assert.IsNotNull(state);
 245                         Assert.IsTrue(state is SameTypeOperationState);
 246                         Assert.AreEqual("Id", state.TargetSuffix);
 247
 248                         bool iterated = false;
 249                         int index = 1;
 250
 251                         foreach (SetItem item in state)
 252                         {
 253                                 iterated = true;
 254
 255                                 Assert.IsNotNull(item.Text);
 256                                 Assert.IsNotNull(item.Value);
 257
 258                                 if (index == 1)
 259                                 {
 260                                         Assert.IsFalse(item.IsSelected);
 261                                         Assert.AreEqual("User", item.Text);
 262                                         Assert.AreEqual("0", item.Value);
 263                                 }
 264                                 else
 265                                 {
 266                                         Assert.IsTrue(item.IsSelected);
 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_SameTypes_NonPrimitive()
 279                 {
 280                         OperationState state = SetOperation.IterateOnDataSource(
 281                                 new Role[] {new Role(0, "User"), new Role(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 SameTypeOperationState);
 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 MultipleValuesInitialSet_DifferentTypes_NonPrimitive()
 319                 {
 320                         OperationState state = SetOperation.IterateOnDataSource(
 321                                 new ProductCategory[] {new ProductCategory(0, "User"), new ProductCategory(1, "Admin")},
 322                                 new Role[] {new Role(0, "User"), new Role(1, "Admin")},
 323                                 DictHelper.Create("text=Name", "value=Id"));
 324
 325                         Assert.IsNotNull(state);
 326                         Assert.IsTrue(state is DifferentTypeOperationState);
 327                         Assert.AreEqual("Id", 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                                 Assert.IsTrue(item.IsSelected);
 339
 340                                 if (index == 1)
 341                                 {
 342                                         Assert.AreEqual("User", item.Text);
 343                                         Assert.AreEqual("0", item.Value);
 344                                 }
 345                                 else
 346                                 {
 347                                         Assert.AreEqual("Admin", item.Text);
 348                                         Assert.AreEqual("1", item.Value);
 349                                 }
 350
 351                                 index++;
 352                         }
 353
 354                         Assert.IsTrue(iterated);
 355                 }
 356
 357                 [Test]
 358                 public void SingleValueInitialSet_DifferentTypes_NonPrimitive_NoNameMatching()
 359                 {
 360                         OperationState state = SetOperation.IterateOnDataSource(
 361                                 new Role2(1, "Admin"),
 362                                 new Role[] {new Role(0, "User"), new Role(1, "Admin")},
 363                                 DictHelper.Create("text=Name", "value=Id", "sourceproperty=identification"));
 364
 365                         Assert.IsNotNull(state);
 366                         Assert.IsTrue(state is DifferentTypeOperationState);
 367                         Assert.AreEqual("Identification", state.TargetSuffix);
 368
 369                         bool iterated = false;
 370                         int index = 1;
 371
 372                         foreach (SetItem item in state)
 373                         {
 374                                 iterated = true;
 375
 376                                 Assert.IsNotNull(item.Text);
 377                                 Assert.IsNotNull(item.Value);
 378
 379                                 if (index == 1)
 380                                 {
 381                                         Assert.IsFalse(item.IsSelected);
 382                                         Assert.AreEqual("User", item.Text);
 383                                         Assert.AreEqual("0", item.Value);
 384                                 }
 385                                 else
 386                                 {
 387                                         Assert.IsTrue(item.IsSelected);
 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                 [Test]
 399                 public void MultipleValuesInitialSet_DifferentTypes_NonPrimitive_NoNameMatching()
 400                 {
 401                         OperationState state = SetOperation.IterateOnDataSource(
 402                                 new Role2[] {new Role2(0, "User"), new Role2(1, "Admin")},
 403                                 new Role[] {new Role(0, "User"), new Role(1, "Admin")},
 404                                 DictHelper.Create("text=Name", "value=Id", "sourceproperty=identification"));
 405
 406                         Assert.IsNotNull(state);
 407                         Assert.IsTrue(state is DifferentTypeOperationState);
 408                         Assert.AreEqual("Identification", state.TargetSuffix);
 409
 410                         bool iterated = false;
 411                         int index = 1;
 412
 413                         foreach (SetItem item in state)
 414                         {
 415                                 iterated = true;
 416
 417                                 Assert.IsNotNull(item.Text);
 418                                 Assert.IsNotNull(item.Value);
 419                                 Assert.IsTrue(item.IsSelected);
 420
 421                                 if (index == 1)
 422                                 {
 423                                         Assert.AreEqual("User", item.Text);
 424                                         Assert.AreEqual("0", item.Value);
 425                                 }
 426                                 else
 427                                 {
 428                                         Assert.AreEqual("Admin", item.Text);
 429                                         Assert.AreEqual("1", item.Value);
 430                                 }
 431
 432                                 index++;
 433                         }
 434
 435                         Assert.IsTrue(iterated);
 436                 }
 437
 438                 /// <summary>
 439                 /// The target is a decimal while the data source is an array of strings
 440                 /// </summary>
 441                 [Test]
 442                 public void SingleSelectionDifferentTypes()
 443                 {
 444                         CultureInfo en = CultureInfo.CreateSpecificCulture("pt-br");
 445
 446                         Thread.CurrentThread.CurrentCulture = en;
 447                         Thread.CurrentThread.CurrentUICulture = en;
 448
 449                         OperationState state = SetOperation.IterateOnDataSource(
 450                                 (decimal?) 1.5,
 451                                 new string[] {"1", "1,5", "2"}, null);
 452                         Assert.IsNotNull(state);
 453                         Assert.IsTrue(state is DifferentTypeOperationState);
 454
 455                         bool iterated = false;
 456                         int index = 0;
 457
 458                         foreach (SetItem item in state)
 459                         {
 460                                 iterated = true;
 461
 462                                 Assert.IsNotNull(item.Text);
 463                                 Assert.IsNotNull(item.Value);
 464
 465                                 if (index == 1)
 466                                 {
 467                                         Assert.IsTrue(item.IsSelected);
 468                                         Assert.AreEqual("1,5", item.Text);
 469                                         Assert.AreEqual("1,5", item.Value);
 470                                 }
 471                                 else
 472                                 {
 473                                         Assert.IsFalse(item.IsSelected);
 474                                 }
 475
 476                                 index++;
 477                         }
 478
 479                         Assert.IsTrue(iterated);
 480                 }
 481
 482                 [Test]
 483                 public void MultipleValuesInitialSet_DifferentTypes_Primitive_NoNameMatching()
 484                 {
 485                         OperationState state = SetOperation.IterateOnDataSource(
 486                                 new int[] {0, 1},
 487                                 new Role[] {new Role(0, "User"), new Role(1, "Admin")},
 488                                 DictHelper.Create("text=Name", "value=Id"));
 489
 490                         Assert.IsNotNull(state);
 491                         Assert.IsTrue(state is DifferentTypeOperationState);
 492                         Assert.AreEqual("", state.TargetSuffix);
 493
 494                         bool iterated = false;
 495                         int index = 1;
 496
 497                         foreach (SetItem item in state)
 498                         {
 499                                 iterated = true;
 500
 501                                 Assert.IsNotNull(item.Text);
 502                                 Assert.IsNotNull(item.Value);
 503                                 Assert.IsTrue(item.IsSelected);
 504
 505                                 if (index == 1)
 506                                 {
 507                                         Assert.AreEqual("User", item.Text);
 508                                         Assert.AreEqual("0", item.Value);
 509                                 }
 510                                 else
 511                                 {
 512                                         Assert.AreEqual("Admin", item.Text);
 513                                         Assert.AreEqual("1", item.Value);
 514                                 }
 515
 516                                 index++;
 517                         }
 518
 519                         Assert.IsTrue(iterated);
 520                 }
 521         }
 522 }