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

   1 //
   2 // DataRelationTest.cs - NUnit Test Cases for  DataRelation
   3 //
   4 // Authors:
   5 //   Ville Palo (vi64pa@koti.soon.fi)
   6 //   Martin Willemoes Hansen (mwh@sysrq.dk)
   7 //
   8 // (C) 2003 Ville Palo
   9 // (C) 2003 Martin Willemoes Hansen
  10 //
  11
  12 //
  13 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
  14 //
  15 // Permission is hereby granted, free of charge, to any person obtaining
  16 // a copy of this software and associated documentation files (the
  17 // "Software"), to deal in the Software without restriction, including
  18 // without limitation the rights to use, copy, modify, merge, publish,
  19 // distribute, sublicense, and/or sell copies of the Software, and to
  20 // permit persons to whom the Software is furnished to do so, subject to
  21 // the following conditions:
  22 //
  23 // The above copyright notice and this permission notice shall be
  24 // included in all copies or substantial portions of the Software.
  25 //
  26 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  27 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  28 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  29 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  30 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  31 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  32 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  33 //
  34
  35 using NUnit.Framework;
  36 using System;
  37 using System.Data;
  38
  39 namespace MonoTests.System.Data
  40 {
  41         [TestFixture]
  42         public class DataRelationTest : Assertion
  43         {
  44                 private DataSet Set = null;
  45                 private DataTable Mom = null;
  46                 private DataTable Child = null;
  47
  48                 [SetUp]
  49                 public void GetReady()
  50                 {
  51                         Set = new DataSet ();
  52                         Mom = new DataTable ("Mom");
  53                         Child = new DataTable ("Child");
  54                         Set.Tables.Add (Mom);
  55                         Set.Tables.Add (Child);
  56
  57                         DataColumn Col = new DataColumn ("Name");
  58                         DataColumn Col2 = new DataColumn ("ChildName");
  59                         Mom.Columns.Add (Col);
  60                         Mom.Columns.Add (Col2);
  61
  62                         DataColumn Col3 = new DataColumn ("Name");
  63                         DataColumn Col4 = new DataColumn ("Age");
  64                         Col4.DataType = Type.GetType ("System.Int16");
  65                         Child.Columns.Add (Col3);
  66                         Child.Columns.Add (Col4);
  67                 }
  68
  69                 [Test]
  70                 public void Foreign ()
  71                 {
  72                         DataRelation Relation = new DataRelation ("Rel", Mom.Columns [1], Child.Columns [0]);
  73                         Set.Relations.Add (Relation);
  74
  75                         DataRow Row = Mom.NewRow ();
  76                         Row [0] = "Teresa";
  77                         Row [1] = "Jack";
  78                         Mom.Rows.Add (Row);
  79
  80                         Row = Mom.NewRow ();
  81                         Row [0] = "Teresa";
  82                         Row [1] = "Dick";
  83                         Mom.Rows.Add (Row);
  84
  85                         Row = Mom.NewRow ();
  86                         Row [0] = "Mary";
  87                         Row [1] = "Harry";
  88
  89                         Row = Child.NewRow ();
  90                         Row [0] = "Jack";
  91                         Row [1] = 16;
  92                         Child.Rows.Add (Row);
  93
  94                         Row = Child.NewRow ();
  95                         Row [0] = "Dick";
  96                         Row [1] = 56;
  97                         Child.Rows.Add (Row);
  98
  99                         AssertEquals ("test#01", 2, Child.Rows.Count);
 100
 101                         Row = Mom.Rows [0];
 102                         Row.Delete ();
 103
 104                         AssertEquals ("test#02", 1, Child.Rows.Count);
 105
 106                         Row = Mom.NewRow ();
 107                         Row [0] = "Teresa";
 108                         Row [1] = "Dick";
 109
 110                         try {
 111                                 Mom.Rows.Add (Row);
 112                                 Fail ("test#03");
 113                         } catch (Exception e) {
 114                                 AssertEquals ("test#04", typeof (ConstraintException), e.GetType ());
 115                                 AssertEquals ("test#05", "Column 'ChildName' is constrained to be unique.  Value 'Dick' is already present.", e.Message);
 116                         }
 117
 118                         Row = Mom.NewRow ();
 119                         Row [0] = "Teresa";
 120                         Row [1] = "Mich";
 121                         Mom.Rows.Add (Row);
 122                         AssertEquals ("test#06", 1, Child.Rows.Count);
 123
 124                         Row = Child.NewRow ();
 125                         Row [0] = "Jack";
 126                         Row [1] = 16;
 127
 128                         try {
 129                                 Child.Rows.Add (Row);
 130                                 Fail ("test#07");
 131                         } catch (Exception e) {
 132                                 AssertEquals ("test#08", typeof (InvalidConstraintException), e.GetType ());
 133                                 AssertEquals ("test#09", "ForeignKeyConstraint Rel requires the child key values (Jack) to exist in the parent table.", e.Message);
 134                         }
 135
 136                 }
 137
 138                 [Test]
 139                 [ExpectedException (typeof(InvalidConstraintException))]
 140                 public void InvalidConstraintException ()
 141                 {
 142                         // Parent Columns and Child Columns don't have type-matching columns.
 143                         DataRelation Relation = new DataRelation ("Rel", Mom.Columns [1], Child.Columns [1], true);
 144                 }
 145
 146                 [Test]
 147                 public void InvalidConstraintException2 ()
 148                 {
 149                         // Parent Columns and Child Columns don't have type-matching columns.
 150                         Child.Columns [1].DataType = Mom.Columns [1].DataType;
 151
 152                         DataRelation Relation = new DataRelation ("Rel", Mom.Columns [1], Child.Columns [1], true);
 153                         Set.Relations.Add (Relation);
 154                         AssertEquals("test#01", 1, Set.Relations.Count);
 155
 156                         Child.Columns [1].DataType = Type.GetType ("System.Double");
 157                 }
 158
 159                 [Test]
 160                 public void DataSetRelations ()
 161                 {
 162                         DataRelation Relation;
 163                         AssertEquals ("test#01", 0, Set.Relations.Count);
 164                         AssertEquals ("test#02", 0, Mom.ParentRelations.Count);
 165                         AssertEquals ("test#03", 0, Mom.ChildRelations.Count);
 166                         AssertEquals ("test#04", 0, Child.ParentRelations.Count);
 167                         AssertEquals ("test#05", 0, Child.ChildRelations.Count);
 168
 169                         Relation = new DataRelation ("Rel", Mom.Columns [1], Child.Columns [0]);
 170                         Set.Relations.Add (Relation);
 171
 172                         AssertEquals ("test#06", 1, Set.Relations.Count);
 173                         AssertEquals ("test#07", 0, Mom.ParentRelations.Count);
 174                         AssertEquals ("test#08", 1, Mom.ChildRelations.Count);
 175                         AssertEquals ("test#09", 1, Child.ParentRelations.Count);
 176                         AssertEquals ("test#10", 0, Child.ChildRelations.Count);
 177
 178                         Relation = Set.Relations [0];
 179                         AssertEquals ("test#11", 1, Relation.ParentColumns.Length);
 180                         AssertEquals ("test#12", 1, Relation.ChildColumns.Length);
 181                         AssertEquals ("test#13", "Rel", Relation.ChildKeyConstraint.ConstraintName);
 182                         AssertEquals ("test#14", "Constraint1", Relation.ParentKeyConstraint.ConstraintName);
 183                 }
 184
 185                 [Test]
 186                 public void Constraints ()
 187                 {
 188
 189                         AssertEquals ("test#01", 0, Mom.Constraints.Count);
 190                         AssertEquals ("test#02", 0, Child.Constraints.Count);
 191
 192                         DataRelation Relation = new DataRelation ("Rel", Mom.Columns [1], Child.Columns [0]);
 193                         Set.Relations.Add (Relation);
 194
 195                         AssertEquals ("test#03", 1, Mom.Constraints.Count);
 196                         AssertEquals ("test#04", 1, Child.Constraints.Count);
 197                         AssertEquals ("test#05", typeof (ForeignKeyConstraint), Child.Constraints [0].GetType ());
 198                         AssertEquals ("test#05", typeof (UniqueConstraint), Mom.Constraints [0].GetType ());
 199
 200                 }
 201
 202                 [Test]
 203                 public void Creation ()
 204                 {
 205
 206                         DataRelation Relation = new DataRelation ("Rel", Mom.Columns [1], Child.Columns [0]);
 207                         Set.Relations.Add (Relation);
 208                         DataRelation Test = null;
 209                         AssertEquals ("test#01", 1, Mom.ChildRelations.Count);
 210                         AssertEquals ("test#02", 0, Child.ChildRelations.Count);
 211                         AssertEquals ("test#03", 0, Mom.ParentRelations.Count);
 212                         AssertEquals ("test#04", 1, Child.ParentRelations.Count);
 213
 214                         Test = Child.ParentRelations [0];
 215                         AssertEquals ("test#05", "Rel", Test.ToString ());
 216                         AssertEquals ("test#06", "Rel", Test.RelationName);
 217                         AssertEquals ("test#07", "Mom", Test.ParentTable.TableName);
 218                         AssertEquals ("test#08", 1, Test.ParentKeyConstraint.Columns.Length);
 219                         AssertEquals ("test#09", false, Test.ParentKeyConstraint.IsPrimaryKey);
 220                         AssertEquals ("test#10", 1, Test.ParentColumns.Length);
 221                         AssertEquals ("test#11", false, Test.Nested);
 222                         AssertEquals ("test#12", 0, Test.ExtendedProperties.Count);
 223                         AssertEquals ("test#13", "Child", Test.ChildTable.TableName);
 224                         AssertEquals ("test#14", "Rel", Test.ChildKeyConstraint.ConstraintName);
 225                         AssertEquals ("test#15", 1, Test.ChildColumns.Length);
 226                 }
 227
 228                 [Test]
 229                 public void Creation2 ()
 230                 {
 231                         DataSet Set = new DataSet ();
 232                         DataTable Mom2 = new DataTable ("Mom");
 233                         DataTable Child2 = new DataTable ("Child");
 234                         DataTable Hubby = new DataTable ("Hubby");
 235                         Set.Tables.Add (Mom2);
 236                         Set.Tables.Add (Child2);
 237                         Set.Tables.Add (Hubby);
 238
 239                         DataColumn Col = new DataColumn ("Name");
 240                         DataColumn Col2 = new DataColumn ("ChildName");
 241                         DataColumn Col3 = new DataColumn ("hubby");
 242                         Mom2.Columns.Add (Col);
 243                         Mom2.Columns.Add (Col2);
 244                         Mom2.Columns.Add (Col3);
 245
 246                         DataColumn Col4 = new DataColumn ("Name");
 247                         DataColumn Col5 = new DataColumn ("Age");
 248                         DataColumn Col6 = new DataColumn ("father");
 249                         Child2.Columns.Add (Col4);
 250                         Child2.Columns.Add (Col5);
 251                         Child2.Columns.Add (Col6);
 252
 253
 254                         DataColumn Col7 = new DataColumn ("Name");
 255                         DataColumn Col8 = new DataColumn ("Age");
 256                         Hubby.Columns.Add (Col7);
 257                         Hubby.Columns.Add (Col8);
 258
 259
 260                         DataColumn [] Parents = new DataColumn [2];
 261                         Parents [0] = Col2;
 262                         Parents [1] = Col3;
 263                         DataColumn [] Childs = new DataColumn [2];
 264                         Childs [0] = Col4;
 265                         Childs [1] = Col7;
 266
 267                         DataRelation Relation = null;
 268                         try {
 269                                 Relation = new DataRelation ("Rel", Parents, Childs);
 270                                 Fail ("test#01");
 271                         } catch (InvalidConstraintException e) {
 272 //                              AssertEquals ("test#02", typeof (InvalidConstraintException), e.GetType ());
 273 //                              AssertEquals ("test#03", "Cannot create a Key from Columns that belong to different tables.", e.Message);
 274                         }
 275
 276                         Childs [1] = Col6;
 277                         Relation = new DataRelation ("Rel", Parents, Childs);
 278
 279                         Set.Relations.Add (Relation);
 280
 281                         DataRelation Test = null;
 282                         AssertEquals ("test#01", 1, Mom2.ChildRelations.Count);
 283                         AssertEquals ("test#02", 0, Child2.ChildRelations.Count);
 284                         AssertEquals ("test#03", 0, Mom2.ParentRelations.Count);
 285                         AssertEquals ("test#04", 1, Child2.ParentRelations.Count);
 286
 287                         Test = Child2.ParentRelations [0];
 288                         AssertEquals ("test#05", "Rel", Test.ToString ());
 289                         AssertEquals ("test#06", "Rel", Test.RelationName);
 290                         AssertEquals ("test#07", "Mom", Test.ParentTable.TableName);
 291                         AssertEquals ("test#08", 2, Test.ParentKeyConstraint.Columns.Length);
 292                         AssertEquals ("test#09", false, Test.ParentKeyConstraint.IsPrimaryKey);
 293                         AssertEquals ("test#10", 2, Test.ParentColumns.Length);
 294                         AssertEquals ("test#11", false, Test.Nested);
 295                         AssertEquals ("test#12", 0, Test.ExtendedProperties.Count);
 296                         AssertEquals ("test#13", "Child", Test.ChildTable.TableName);
 297                         AssertEquals ("test#14", "Rel", Test.ChildKeyConstraint.ConstraintName);
 298                         AssertEquals ("test#15", 2, Test.ChildColumns.Length);
 299                         AssertEquals ("test#16", 1, Mom2.Constraints.Count);
 300                         AssertEquals ("test#17", "Constraint1", Mom2.Constraints [0].ToString ());
 301                         AssertEquals ("test#18", 1, Child2.Constraints.Count);
 302                         AssertEquals ("test#19", 0, Hubby.Constraints.Count);
 303                 }
 304
 305                 [Test]
 306                 public void Creation3 ()
 307                 {
 308
 309                         DataRelation Relation = new DataRelation ("Rel", Mom.Columns [1], Child.Columns [0], false);
 310                         Set.Relations.Add (Relation);
 311                         DataRelation Test = null;
 312
 313                         AssertEquals ("test#01", 1, Mom.ChildRelations.Count);
 314                         AssertEquals ("test#02", 0, Child.ChildRelations.Count);
 315                         AssertEquals ("test#03", 0, Mom.ParentRelations.Count);
 316                         AssertEquals ("test#04", 1, Child.ParentRelations.Count);
 317
 318                         Test = Child.ParentRelations [0];
 319
 320                         AssertEquals ("test#05", "Rel", Test.ToString ());
 321
 322                         AssertEquals ("test#06", "Rel", Test.RelationName);
 323                         AssertEquals ("test#07", "Mom", Test.ParentTable.TableName);
 324
 325                         Assert ("test#08", Test.ParentKeyConstraint == null);
 326
 327                         Assert ("test#09", Test.ParentKeyConstraint == null);
 328
 329                         AssertEquals ("test#10", 1, Test.ParentColumns.Length);
 330                         AssertEquals ("test#11", false, Test.Nested);
 331                         AssertEquals ("test#12", 0, Test.ExtendedProperties.Count);
 332                         AssertEquals ("test#13", "Child", Test.ChildTable.TableName);
 333
 334                         Assert ("test#14", Test.ChildKeyConstraint == null);
 335                         AssertEquals ("test#15", 1, Test.ChildColumns.Length);
 336                         AssertEquals ("test#16", 0, Mom.Constraints.Count);
 337                         AssertEquals ("test#17", 0, Child.Constraints.Count);
 338
 339                 }
 340
 341                 [Test]
 342                 [Ignore ("Set.Relations.AddRange() fails, but why?")]
 343                 public void Creation4 ()
 344                 {
 345
 346                         DataRelation Relation = new DataRelation ("Rel", "Mom", "Child",
 347                                                                   new string [] {"ChildName"},
 348                                                                   new string [] {"Name"}, true);
 349
 350                         try {
 351                                 Set.Relations.Add (Relation);
 352                                 Fail ("test#01");
 353                         } catch (Exception e) {
 354                                 AssertEquals ("test#02", typeof (NullReferenceException), e.GetType ());
 355                         }
 356
 357                         try {
 358                                 Set.Relations.AddRange (new DataRelation [] {Relation});
 359                                 Fail ("test#03");
 360                         } catch (Exception e) {
 361                                 AssertEquals ("test#04", typeof (NullReferenceException), e.GetType ());
 362                         }
 363
 364                         //Set.BeginInit ();
 365                         Set.Relations.AddRange (new DataRelation [] {Relation});
 366                         //Set.EndInit ();
 367
 368                         DataRelation Test = null;
 369                         AssertEquals ("test#01", 1, Mom.ChildRelations.Count);
 370                         AssertEquals ("test#02", 0, Child.ChildRelations.Count);
 371                         AssertEquals ("test#03", 0, Mom.ParentRelations.Count);
 372                         AssertEquals ("test#04", 1, Child.ParentRelations.Count);
 373
 374                         Test = Child.ParentRelations [0];
 375                         AssertEquals ("test#05", "Rel", Test.ToString ());
 376                         AssertEquals ("test#06", "Rel", Test.RelationName);
 377                         AssertEquals ("test#07", "Mom", Test.ParentTable.TableName);
 378
 379                         AssertEquals ("test#08", true, Test.ParentKeyConstraint == null);
 380
 381                         AssertEquals ("test#10", 1, Test.ParentColumns.Length);
 382                         AssertEquals ("test#11", true, Test.Nested);
 383                         AssertEquals ("test#12", 0, Test.ExtendedProperties.Count);
 384                         AssertEquals ("test#13", "Child", Test.ChildTable.TableName);
 385                         AssertEquals ("test#14", true, Test.ChildKeyConstraint == null);
 386                         AssertEquals ("test#15", 1, Test.ChildColumns.Length);
 387
 388                 }
 389
 390                 [Test]
 391                 public void RelationFromSchema ()
 392                 {
 393                         DataSet Set = new DataSet ();
 394                         Set.ReadXmlSchema ("Test/System.Data/store.xsd");
 395                         DataTable Table = Set.Tables [0];
 396
 397                         AssertEquals ("test#01", false, Table.CaseSensitive);
 398                         AssertEquals ("test#02", 1, Table.ChildRelations.Count);
 399                         AssertEquals ("test#03", 0, Table.ParentRelations.Count);
 400                         AssertEquals ("test#04", 1, Table.Constraints.Count);
 401                         AssertEquals ("test#05", 1, Table.PrimaryKey.Length);
 402                         AssertEquals ("test#06", 0, Table.Rows.Count);
 403                         AssertEquals ("test#07", "bookstore", Table.TableName);
 404                         AssertEquals ("test#08", 1, Table.Columns.Count);
 405
 406                         DataRelation Relation = Table.ChildRelations [0];
 407                         AssertEquals ("test#09", 1, Relation.ChildColumns.Length);
 408                         AssertEquals ("test#10", "bookstore_book", Relation.ChildKeyConstraint.ConstraintName);
 409                         AssertEquals ("test#11", 1, Relation.ChildKeyConstraint.Columns.Length);
 410                         AssertEquals ("test#12", "book", Relation.ChildTable.TableName);
 411                         AssertEquals ("test#13", "NewDataSet", Relation.DataSet.DataSetName);
 412                         AssertEquals ("test#14", 0, Relation.ExtendedProperties.Count);
 413                         AssertEquals ("test#15", true, Relation.Nested);
 414                         AssertEquals ("test#16", 1, Relation.ParentColumns.Length);
 415                         AssertEquals ("test#17", "Constraint1", Relation.ParentKeyConstraint.ConstraintName);
 416                         AssertEquals ("test#18", "bookstore", Relation.ParentTable.TableName);
 417                         AssertEquals ("test#19", "bookstore_book", Relation.RelationName);
 418
 419                         Table = Set.Tables [1];
 420
 421                         AssertEquals ("test#20", false, Table.CaseSensitive);
 422                         AssertEquals ("test#21", 1, Table.ChildRelations.Count);
 423                         AssertEquals ("test#22", 1, Table.ParentRelations.Count);
 424                         AssertEquals ("test#23", 2, Table.Constraints.Count);
 425                         AssertEquals ("test#24", 1, Table.PrimaryKey.Length);
 426                         AssertEquals ("test#25", 0, Table.Rows.Count);
 427                         AssertEquals ("test#26", "book", Table.TableName);
 428                         AssertEquals ("test#27", 5, Table.Columns.Count);
 429
 430                         Relation = Table.ChildRelations [0];
 431                         AssertEquals ("test#28", 1, Relation.ChildColumns.Length);
 432                         AssertEquals ("test#29", "book_author", Relation.ChildKeyConstraint.ConstraintName);
 433                         AssertEquals ("test#30", 1, Relation.ChildKeyConstraint.Columns.Length);
 434                         AssertEquals ("test#31", "author", Relation.ChildTable.TableName);
 435                         AssertEquals ("test#32", "NewDataSet", Relation.DataSet.DataSetName);
 436                         AssertEquals ("test#33", 0, Relation.ExtendedProperties.Count);
 437                         AssertEquals ("test#34", true, Relation.Nested);
 438                         AssertEquals ("test#35", 1, Relation.ParentColumns.Length);
 439                         AssertEquals ("test#36", "Constraint1", Relation.ParentKeyConstraint.ConstraintName);
 440                         AssertEquals ("test#37", "book", Relation.ParentTable.TableName);
 441                         AssertEquals ("test#38", "book_author", Relation.RelationName);
 442
 443                         Table = Set.Tables [2];
 444                         AssertEquals ("test#39", false, Table.CaseSensitive);
 445                         AssertEquals ("test#40", 0, Table.ChildRelations.Count);
 446                         AssertEquals ("test#41", 1, Table.ParentRelations.Count);
 447                         AssertEquals ("test#42", 1, Table.Constraints.Count);
 448                         AssertEquals ("test#43", 0, Table.PrimaryKey.Length);
 449                         AssertEquals ("test#44", 0, Table.Rows.Count);
 450                         AssertEquals ("test#45", "author", Table.TableName);
 451                         AssertEquals ("test#46", 3, Table.Columns.Count);
 452                 }
 453
 454                 [Test]
 455                 public void ChildRows ()
 456                 {
 457
 458                         DataRelation Relation = new DataRelation ("Rel", Mom.Columns [1], Child.Columns [0]);
 459                         Set.Relations.Add (Relation);
 460
 461                         DataRow TempRow = Mom.NewRow ();
 462                         TempRow [0] = "teresa";
 463                         TempRow [1] = "john";
 464                         Mom.Rows.Add (TempRow);
 465
 466                         TempRow = Mom.NewRow ();
 467                         TempRow [0] = "teresa";
 468                         TempRow [1] = "Dick";
 469                         Mom.Rows.Add (TempRow);
 470
 471                         TempRow = Child.NewRow ();
 472                         TempRow [0] = "john";
 473                         TempRow [1] = "15";
 474                         Child.Rows.Add (TempRow);
 475
 476                         TempRow = Child.NewRow ();
 477                         TempRow [0] = "Dick";
 478                         TempRow [1] = "10";
 479                         Child.Rows.Add (TempRow);
 480
 481                         DataRow Row = Mom.Rows [1];
 482                         TempRow = Row.GetChildRows ("Rel") [0];
 483                         AssertEquals ("test#01", "Dick", TempRow [0]);
 484                         AssertEquals ("test#02", "10", TempRow [1].ToString ());
 485                         TempRow = TempRow.GetParentRow ("Rel");
 486                         AssertEquals ("test#03", "teresa", TempRow [0]);
 487                         AssertEquals ("test#04", "Dick", TempRow [1]);
 488
 489                         Row = Child.Rows [0];
 490                         TempRow = Row.GetParentRows ("Rel") [0];
 491                         AssertEquals ("test#05", "teresa", TempRow [0]);
 492                         AssertEquals ("test#06", "john", TempRow [1]);
 493                 }
 494
 495         }
 496 }