mcs/class/System.Data/Test/System.Data/DataRelationTest2.cs

   1 // Authors:
   2 //   Rafael Mizrahi   <rafim@mainsoft.com>
   3 //   Erez Lotan       <erezl@mainsoft.com>
   4 //   Oren Gurfinkel   <oreng@mainsoft.com>
   5 //   Ofer Borstein
   6 //
   7 // Copyright (c) 2004 Mainsoft Co.
   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
  29 using NUnit.Framework;
  30 using System;
  31 using System.ComponentModel;
  32 using System.Data;
  33 using MonoTests.System.Data.Utils;
  34
  35 namespace MonoTests.System.Data
  36 {
  37         [TestFixture] public class DataRelationTest2
  38         {
  39                 [Test] public void ChildColumns()
  40                 {
  41                         DataSet ds = new DataSet();
  42                         DataTable dtChild = DataProvider.CreateChildDataTable();
  43                         DataTable dtParent = DataProvider.CreateParentDataTable();
  44                         ds.Tables.Add(dtParent);
  45                         ds.Tables.Add(dtChild);
  46
  47                         DataRelation dRel;
  48                         dRel = new DataRelation("MyRelation",dtParent.Columns[0],dtChild.Columns[0]);
  49                         ds.Relations.Add(dRel);
  50
  51                         // ChildColumns 1
  52                         Assert.AreEqual(1 , dRel.ChildColumns.Length , "DR1");
  53
  54                         // ChildColumns 2
  55                         Assert.AreEqual(dtChild.Columns[0] , dRel.ChildColumns[0] , "DR2");
  56                 }
  57
  58                 [Test] public void ChildKeyConstraint()
  59                 {
  60                         DataSet ds = new DataSet();
  61                         DataTable dtChild = DataProvider.CreateChildDataTable();
  62                         DataTable dtParent = DataProvider.CreateParentDataTable();
  63                         ds.Tables.Add(dtParent);
  64                         ds.Tables.Add(dtChild);
  65
  66                         DataRelation dRel;
  67                         dRel = new DataRelation("MyRelation",dtParent.Columns[0],dtChild.Columns[0]);
  68                         ds.Relations.Add(dRel);
  69
  70                         // ChildKeyConstraint 1
  71                         Assert.AreEqual(dtChild.Constraints[0] , dRel.ChildKeyConstraint, "DR3");
  72                 }
  73
  74                 [Test] public void ChildTable()
  75                 {
  76                         DataSet ds = new DataSet();
  77                         DataTable dtChild = DataProvider.CreateChildDataTable();
  78                         DataTable dtParent = DataProvider.CreateParentDataTable();
  79                         ds.Tables.Add(dtParent);
  80                         ds.Tables.Add(dtChild);
  81
  82                         DataRelation dRel;
  83                         dRel = new DataRelation("MyRelation",dtParent.Columns[0],dtChild.Columns[0]);
  84                         ds.Relations.Add(dRel);
  85
  86                         // ChildTable
  87                         Assert.AreEqual(dtChild , dRel.ChildTable , "DR4");
  88                 }
  89
  90                 [Test] public void DataSet()
  91                 {
  92                         DataSet ds = new DataSet();
  93                         DataTable dtChild = DataProvider.CreateChildDataTable();
  94                         DataTable dtParent = DataProvider.CreateParentDataTable();
  95                         ds.Tables.Add(dtParent);
  96                         ds.Tables.Add(dtChild);
  97
  98                         DataRelation dRel;
  99                         dRel = new DataRelation("MyRelation",dtParent.Columns[0],dtChild.Columns[0]);
 100                         ds.Relations.Add(dRel);
 101
 102                         // DataSet
 103                         Assert.AreEqual(ds , dRel.DataSet , "DR5");
 104                 }
 105
 106                 [Test] public void ParentColumns()
 107                 {
 108                         DataSet ds = new DataSet();
 109                         DataTable dtChild = DataProvider.CreateChildDataTable();
 110                         DataTable dtParent = DataProvider.CreateParentDataTable();
 111                         ds.Tables.Add(dtParent);
 112                         ds.Tables.Add(dtChild);
 113
 114                         DataRelation dRel;
 115                         dRel = new DataRelation("MyRelation",dtParent.Columns[0],dtChild.Columns[0]);
 116                         ds.Relations.Add(dRel);
 117
 118                         // ParentColumns 1
 119                         Assert.AreEqual(1 , dRel.ParentColumns.Length , "DR6");
 120
 121                         // ParentColumns 2
 122                         Assert.AreEqual(dtParent.Columns[0] , dRel.ParentColumns[0] , "DR7");
 123                 }
 124
 125                 [Test] public void ParentKeyConstraint()
 126                 {
 127                         DataSet ds = new DataSet();
 128                         DataTable dtChild = DataProvider.CreateChildDataTable();
 129                         DataTable dtParent = DataProvider.CreateParentDataTable();
 130                         ds.Tables.Add(dtParent);
 131                         ds.Tables.Add(dtChild);
 132
 133                         DataRelation dRel;
 134                         dRel = new DataRelation("MyRelation",dtParent.Columns[0],dtChild.Columns[0]);
 135                         ds.Relations.Add(dRel);
 136
 137                         // ChildKeyConstraint 1
 138                         Assert.AreEqual(dtParent.Constraints[0] , dRel.ParentKeyConstraint , "DR8");
 139                 }
 140
 141                 [Test] public void ParentTable()
 142                 {
 143                         DataSet ds = new DataSet();
 144                         DataTable dtChild = DataProvider.CreateChildDataTable();
 145                         DataTable dtParent = DataProvider.CreateParentDataTable();
 146                         ds.Tables.Add(dtParent);
 147                         ds.Tables.Add(dtChild);
 148
 149                         DataRelation dRel;
 150                         dRel = new DataRelation("MyRelation",dtParent.Columns[0],dtChild.Columns[0]);
 151                         ds.Relations.Add(dRel);
 152
 153                         // ParentTable
 154                         Assert.AreEqual(dtParent , dRel.ParentTable , "DR9");
 155                 }
 156
 157                 [Test] public new void ToString()
 158                 {
 159                         DataSet ds = new DataSet();
 160                         DataTable dtChild = DataProvider.CreateChildDataTable();
 161                         DataTable dtParent = DataProvider.CreateParentDataTable();
 162                         ds.Tables.Add(dtParent);
 163                         ds.Tables.Add(dtChild);
 164
 165                         DataRelation dRel;
 166                         dRel = new DataRelation(null,dtParent.Columns[0],dtChild.Columns[0]);
 167
 168                         // ToString 1
 169                         Assert.AreEqual(string.Empty , dRel.ToString() , "DR10");
 170
 171                         ds.Relations.Add(dRel);
 172
 173                         // ToString 2
 174                         Assert.AreEqual("Relation1", dRel.ToString() , "DR11");
 175
 176                         dRel.RelationName = "myRelation";
 177
 178                         // ToString 3
 179                         Assert.AreEqual("myRelation", dRel.ToString() , "DR12");
 180                 }
 181
 182                 [Test] public void ctor_ByNameDataColumns()
 183                 {
 184                         DataSet ds = new DataSet();
 185                         DataTable dtChild = DataProvider.CreateChildDataTable();
 186                         DataTable dtParent = DataProvider.CreateParentDataTable();
 187                         ds.Tables.Add(dtParent);
 188                         ds.Tables.Add(dtChild);
 189
 190                         DataRelation dRel;
 191                         dRel = new DataRelation("MyRelation",dtParent.Columns[0],dtChild.Columns[0]);
 192                         ds.Relations.Add(dRel);
 193
 194                         // DataRelation - CTor
 195                         Assert.AreEqual(false , dRel == null , "DR13");
 196
 197                         // DataRelation - parent Constraints
 198                         Assert.AreEqual(1, dtParent.Constraints.Count , "DR14");
 199
 200                         // DataRelation - child Constraints
 201                         Assert.AreEqual(1, dtChild.Constraints.Count , "DR15");
 202
 203                         // DataRelation - child relations
 204                         Assert.AreEqual(dRel, dtParent.ChildRelations[0] , "DR16");
 205
 206                         // DataRelation - parent relations
 207                         Assert.AreEqual(dRel , dtChild.ParentRelations[0], "DR17");
 208
 209                         // DataRelation - name
 210                         Assert.AreEqual("MyRelation" , dRel.RelationName , "DR18");
 211
 212                         // DataRelation - parent UniqueConstraint
 213                         Assert.AreEqual(typeof(UniqueConstraint), dtParent.Constraints[0].GetType() , "DR19");
 214
 215                         // DataRelation - Child ForeignKeyConstraint
 216                         Assert.AreEqual(typeof(ForeignKeyConstraint), dtChild.Constraints[0].GetType() , "DR20");
 217
 218                         ds.Relations.Clear();
 219                         // Remove DataRelation - Parent Constraints
 220                         Assert.AreEqual(1, dtParent.Constraints.Count , "DR21");
 221
 222                         // Remove DataRelation - Child Constraints
 223                         Assert.AreEqual(1, dtChild.Constraints.Count , "DR22");
 224
 225                         // Remove DataRelation - child relations
 226                         Assert.AreEqual(0, dtParent.ChildRelations.Count , "DR23");
 227
 228                         // Remove DataRelation - parent relations
 229                         Assert.AreEqual(0, dtChild.ParentRelations.Count , "DR24");
 230
 231                         //add relation which will create invalid constraint
 232                         dtChild.Constraints.Clear();
 233                         dtParent.Constraints.Clear();
 234                         //add duplicated row
 235                         dtParent.Rows.Add(dtParent.Rows[0].ItemArray);
 236                         dRel = new DataRelation("MyRelation",dtParent.Columns[0],dtChild.Columns[0]);
 237
 238                         // Add relation which will create invalid constraint
 239                         try {
 240                                 ds.Relations.Add(dRel);
 241                                 Assert.Fail("DR25: Add failed to throw ArgmentException");
 242                         }
 243                         catch (ArgumentException) {}
 244                         catch (AssertionException exc) {throw  exc;}
 245                         catch (Exception exc)
 246                         {
 247                                 Assert.Fail("DR26: Add. Wrong exception type. Got:" + exc);
 248                         }
 249                 }
 250
 251                 [Test] public void ctor_ByNameDataColumnsCreateConstraints()
 252                 {
 253                         DataRelation dRel;
 254                         DataTable dtChild = DataProvider.CreateChildDataTable();
 255                         DataTable dtParent = DataProvider.CreateParentDataTable();
 256
 257                         DataSet ds = new DataSet();
 258                         ds.Tables.Add(dtParent);
 259                         ds.Tables.Add(dtChild);
 260
 261                         //parameter createConstraints = true
 262
 263                         bool createConstraints = true;
 264                         for (int i=0; i<=1; i++)
 265                         {
 266                                 if (i==0)
 267                                         createConstraints = false;
 268                                 else
 269                                         createConstraints = true;
 270
 271                                 ds.Relations.Clear();
 272                                 dtParent.Constraints.Clear();
 273                                 dtChild.Constraints.Clear();
 274
 275                                 //add duplicated row
 276                                 dtParent.Rows.Add(dtParent.Rows[0].ItemArray);
 277                                 dRel = new DataRelation("MyRelation",dtParent.Columns[0],dtChild.Columns[0],createConstraints);
 278                                 // Add relation which will create invalid constraint
 279                                 if (createConstraints==true)
 280                                 {
 281                                         try {
 282                                                 ds.Relations.Add(dRel);
 283                                                 Assert.Fail("DR27: Add failed to throw ArgmentException");
 284                                         }
 285                                         catch (ArgumentException) {}
 286                                         catch (AssertionException exc) {throw  exc;}
 287                                         catch (Exception exc)
 288                                         {
 289                                                 Assert.Fail("DR28: Add. Wrong exception type. Got:" + exc);
 290                                         }
 291                                 }
 292                                 else
 293                                         ds.Relations.Add(dRel);
 294
 295                                 dtParent.Rows.Remove(dtParent.Rows[dtParent.Rows.Count-1]);
 296                                 ds.Relations.Clear();
 297                                 dtParent.Constraints.Clear();
 298                                 dtChild.Constraints.Clear();
 299                                 dRel = new DataRelation("MyRelation",dtParent.Columns[0],dtChild.Columns[0],createConstraints);
 300                                 ds.Relations.Add(dRel);
 301
 302                                 // DataRelation - CTor,createConstraints=
 303                                 Assert.AreEqual(false , dRel == null , "DR29:" + createConstraints.ToString());
 304
 305                                 // DataRelation - parent Constraints,createConstraints=
 306                                 Assert.AreEqual(i, dtParent.Constraints.Count , "DR30:" + createConstraints.ToString());
 307
 308                                 // DataRelation - child Constraints,createConstraints=
 309                                 Assert.AreEqual(i, dtChild.Constraints.Count , "DR31:" + createConstraints.ToString());
 310
 311                                 // DataRelation - child relations,createConstraints=
 312                                 Assert.AreEqual(dRel, dtParent.ChildRelations[0] , "DR32:" + createConstraints.ToString());
 313
 314                                 // DataRelation - parent relations,createConstraints=
 315                                 Assert.AreEqual(dRel , dtChild.ParentRelations[0], "DR33:" + createConstraints.ToString());
 316
 317                                 // DataRelation - name
 318                                 Assert.AreEqual("MyRelation" , dRel.RelationName , "DR34");
 319                         }
 320                 }
 321
 322                 [Test] public void ctor_ByNameDataColumnsArrays()
 323                 {
 324                         DataSet ds = new DataSet();
 325                         DataTable dtChild = DataProvider.CreateChildDataTable();
 326                         DataTable dtParent = DataProvider.CreateParentDataTable();
 327                         ds.Tables.Add(dtParent);
 328                         ds.Tables.Add(dtChild);
 329
 330                         DataRelation dRel;
 331
 332                         //check some exception
 333                         // DataRelation - CTor ArgumentException, two columns child
 334                         try {
 335                                 dRel = new DataRelation("MyRelation",new DataColumn[] {dtParent.Columns[0]},new DataColumn[]  {dtChild.Columns[0],dtChild.Columns[2]});
 336                                 Assert.Fail("DR35: ctor failed to throw ArgmentException");
 337                         }
 338                         catch (ArgumentException) {}
 339                         catch (AssertionException exc) {throw  exc;}
 340                         catch (Exception exc)
 341                         {
 342                                 Assert.Fail("DR36: ctor. Wrong exception type. Got:" + exc);
 343                         }
 344
 345                         dRel = new DataRelation("MyRelation",new DataColumn[] {dtParent.Columns[0],dtParent.Columns[1]},new DataColumn[]  {dtChild.Columns[0],dtChild.Columns[2]});
 346                         // DataRelation - Add Relation ArgumentException, fail on creating child Constraints
 347                         try {
 348                                 ds.Relations.Add(dRel);
 349                                 Assert.Fail("DR37: Add failed to throw ArgmentException");
 350                         }
 351                         catch (ArgumentException) {}
 352                         catch (AssertionException exc) {throw  exc;}
 353                         catch (Exception exc)
 354                         {
 355                                 Assert.Fail("DR38: Add. Wrong exception type. Got:" + exc);
 356                         }
 357
 358                         // DataRelation ArgumentException - parent Constraints
 359                         Assert.AreEqual(1, dtParent.Constraints.Count , "DR39");
 360
 361                         // DataRelation ArgumentException - child Constraints
 362                         Assert.AreEqual(0, dtChild.Constraints.Count , "DR40");
 363
 364                         // DataRelation ArgumentException - DataSet.Relation count
 365                         Assert.AreEqual(1, ds.Relations.Count , "DR41");
 366
 367                         //begin to check the relation ctor
 368                         dtParent.Constraints.Clear();
 369                         dtChild.Constraints.Clear();
 370                         ds.Relations.Clear();
 371                         dRel = new DataRelation("MyRelation",new DataColumn[] {dtParent.Columns[0]},new DataColumn[]  {dtChild.Columns[0]});
 372                         ds.Relations.Add(dRel);
 373
 374                         // DataSet DataRelation count
 375                         Assert.AreEqual(1, ds.Relations.Count , "DR42");
 376
 377                         // DataRelation - CTor
 378                         Assert.AreEqual(false , dRel == null , "DR43");
 379
 380                         // DataRelation - parent Constraints
 381                         Assert.AreEqual(1, dtParent.Constraints.Count , "DR44");
 382
 383                         // DataRelation - child Constraints
 384                         Assert.AreEqual(1, dtChild.Constraints.Count , "DR45");
 385
 386                         // DataRelation - child relations
 387                         Assert.AreEqual(dRel, dtParent.ChildRelations[0] , "DR46");
 388
 389                         // DataRelation - parent relations
 390                         Assert.AreEqual(dRel , dtChild.ParentRelations[0], "DR47");
 391
 392                         // DataRelation - name
 393                         Assert.AreEqual("MyRelation" , dRel.RelationName , "DR48");
 394                 }
 395
 396                 [Test] public void ctor_ByNameDataColumnsArraysCreateConstraints()
 397                 {
 398                         DataRelation dRel;
 399                         DataTable dtChild = DataProvider.CreateChildDataTable();
 400                         DataTable dtParent = DataProvider.CreateParentDataTable();
 401
 402                         DataSet ds = new DataSet();
 403                         ds.Tables.Add(dtParent);
 404                         ds.Tables.Add(dtChild);
 405
 406                         //parameter createConstraints = true
 407
 408                         bool createConstraints = true;
 409                         for (int i=0; i<=1; i++)
 410                         {
 411                                 if (i==0)
 412                                         createConstraints = false;
 413                                 else
 414                                         createConstraints = true;
 415
 416                                 ds.Relations.Clear();
 417                                 dtParent.Constraints.Clear();
 418                                 dtChild.Constraints.Clear();
 419
 420                                 //add duplicated row
 421                                 dtParent.Rows.Add(dtParent.Rows[0].ItemArray);
 422                                 dRel = new DataRelation("MyRelation",new DataColumn[] {dtParent.Columns[0]},new DataColumn[]  {dtChild.Columns[0]},createConstraints);
 423                                 // Add relation which will create invalid constraint
 424                                 if (createConstraints==true)
 425                                 {
 426                                         try {
 427                                                 ds.Relations.Add(dRel);
 428                                                 Assert.Fail("DR49: Add failed to throw ArgmentException");
 429                                         }
 430                                         catch (ArgumentException) {}
 431                                         catch (AssertionException exc) {throw  exc;}
 432                                         catch (Exception exc)
 433                                         {
 434                                                 Assert.Fail("DR50: Add. Wrong exception type. Got:" + exc);
 435                                         }
 436                                 }
 437                                 else
 438                                         ds.Relations.Add(dRel);
 439
 440                                 ds.Relations.Clear();
 441                                 dtParent.Constraints.Clear();
 442                                 dtChild.Constraints.Clear();
 443                                 dtParent.Rows.Remove(dtParent.Rows[dtParent.Rows.Count-1]);
 444
 445                                 dRel = new DataRelation("MyRelation",new DataColumn[] {dtParent.Columns[0]},new DataColumn[]  {dtChild.Columns[0]},createConstraints);
 446                                 ds.Relations.Add(dRel);
 447
 448                                 // DataRelation - CTor,createConstraints=
 449                                 Assert.AreEqual(false, dRel == null, "DR51:" + createConstraints.ToString());
 450
 451                                 // DataRelation - parent Constraints,createConstraints=
 452                                 Assert.AreEqual(i, dtParent.Constraints.Count , "DR52:" + createConstraints.ToString());
 453
 454                                 // DataRelation - child Constraints,createConstraints=
 455                                 Assert.AreEqual(i, dtChild.Constraints.Count , "DR53:" + createConstraints.ToString());
 456
 457                                 // DataRelation - child relations,createConstraints=
 458                                 Assert.AreEqual(dRel, dtParent.ChildRelations[0] , "DR54:" + createConstraints.ToString());
 459
 460                                 // DataRelation - parent relations,createConstraints=
 461                                 Assert.AreEqual(dRel , dtChild.ParentRelations[0], "DR55:" + createConstraints.ToString());
 462
 463                                 // DataRelation - name
 464                                 Assert.AreEqual("MyRelation" , dRel.RelationName , "DR56");
 465                         }
 466                 }
 467
 468                 [Test] public void extendedProperties()
 469                 {
 470                         DataSet ds = new DataSet();
 471                         DataTable dtChild = DataProvider.CreateChildDataTable();
 472                         DataTable dtParent = DataProvider.CreateParentDataTable();
 473                         ds.Tables.Add(dtParent);
 474                         ds.Tables.Add(dtChild);
 475
 476                         DataRelation dRel;
 477                         dRel = new DataRelation("MyRelation",dtParent.Columns[0],dtChild.Columns[0]);
 478                         ds.Relations.Add(dRel);
 479
 480                         PropertyCollection pc;
 481                         pc = dRel.ExtendedProperties ;
 482
 483                         // Checking ExtendedProperties default
 484                         Assert.AreEqual(true, pc != null, "DR57");
 485
 486                         // Checking ExtendedProperties count
 487                         Assert.AreEqual(0, pc.Count , "DR58");
 488                 }
 489
 490                 [Test] public void nested()
 491                 {
 492                         DataSet ds = new DataSet();
 493                         DataTable dtChild = DataProvider.CreateChildDataTable();
 494                         DataTable dtParent = DataProvider.CreateParentDataTable();
 495                         ds.Tables.Add(dtParent);
 496                         ds.Tables.Add(dtChild);
 497
 498                         DataRelation dRel;
 499                         dRel = new DataRelation(null,dtParent.Columns[0],dtChild.Columns[0]);
 500                         ds.Relations.Add(dRel);
 501
 502                         // Nested default
 503                         Assert.AreEqual(false, dRel.Nested  , "DR59");
 504
 505                         dRel.Nested = true;
 506
 507                         // Nested get/set
 508                         Assert.AreEqual(true, dRel.Nested , "DR60");
 509                 }
 510
 511                 [Test] public void relationName()
 512                 {
 513                         DataSet ds = new DataSet();
 514                         DataTable dtChild = DataProvider.CreateChildDataTable();
 515                         DataTable dtParent = DataProvider.CreateParentDataTable();
 516                         ds.Tables.Add(dtParent);
 517                         ds.Tables.Add(dtChild);
 518
 519                         DataRelation dRel;
 520                         dRel = new DataRelation(null,dtParent.Columns[0],dtChild.Columns[0]);
 521
 522                         // RelationName default 1
 523                         Assert.AreEqual(string.Empty , dRel.RelationName , "DR61");
 524
 525                         ds.Relations.Add(dRel);
 526
 527                         // RelationName default 2
 528                         Assert.AreEqual("Relation1", dRel.RelationName , "DR62");
 529
 530                         dRel.RelationName = "myRelation";
 531
 532                         // RelationName get/set
 533                         Assert.AreEqual("myRelation", dRel.RelationName , "DR63");
 534                 }
 535         }
 536 }