Datei: IntegrationTests/IntegrationTests/Rel1toNDirectedWTable.cs

Last Commit (60aa080)
1 //
2 // Copyright (c) 2002-2016 Mirko Matytschak
3 // (www.netdataobjects.de)
4 //
5 // Author: Mirko Matytschak
6 //
7 // Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
8 // documentation files (the "Software"), to deal in the Software without restriction, including without limitation
9 // the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
10 // Software, and to permit persons to whom the Software is furnished to do so, subject to the following
11 // conditions:
12
13 // The above copyright notice and this permission notice shall be included in all copies or substantial portions
14 // of the Software.
15 //
16 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
17 // TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
19 // CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
20 // DEALINGS IN THE SOFTWARE.
21
22
23 using System;
24 using System.Collections;
25 using NDO;
26 using NDO.Query;
27 using NUnit.Framework;
28 using Reisekosten;
29 using Reisekosten.Personal;
30
31 namespace NdoUnitTests
32 {
33 ····/// <summary>
34 ····/// This class contains all tests for 1:n directed relations with an intermediate mapping table.
35 ····/// </summary>
36 ····[TestFixture]
37 ····public class Rel1toNDirectedWTable : NDOTest
38 ····{
39
40 ········public Rel1toNDirectedWTable()
41 ········{
42 ········}
43
44 ········private PersistenceManager pm;
45 ········private Mitarbeiter m;
46 ········private Reisebüro r;
47 ········private Reisebüro r2;
48
49 ········[SetUp]
50 ········public void Setup()
51 ········{
52 ············pm = PmFactory.NewPersistenceManager();
53 ············m = CreateMitarbeiter( "Hartmut", "Kocher" );
54 ············r = CreateReisebüro( "Lufthansa City Center" );
55 ········}
56
57 ········[TearDown]
58 ········public void TearDown()
59 ········{
60 ············pm.Abort();
61 ············IList mitarbeiterListe = pm.GetClassExtent( typeof( Mitarbeiter ), false );
62 ············pm.Delete( mitarbeiterListe );
63 ············IList rbListe = pm.GetClassExtent( typeof( Reisebüro ), false );
64 ············pm.Delete( rbListe );
65 ············pm.Save();
 
 
 
 
 
66 ············pm.Close();
67 ············pm = null;
68 ········}
69
70 ········[Test]
71 ········public void TestCreateObjects()
72 ········{
73 ············pm.MakePersistent( r );
74 ············if (r.NDOObjectId.Id[0] is Int32 && !pm.HasOwnerCreatedIds)
75 ················Assert.That((int)r.NDOObjectId.Id[0] == -1, "Reisebüro key wrong" );
76 ············Reisebüro r2 = (Reisebüro)pm.FindObject( r.NDOObjectId );
77 ············Assert.That(Object.ReferenceEquals(r, r2), "Reisebüros should match" );
78 ········}
79
80 ········[Test]
81 ········public void TestCreateObjectsTransient1()
82 ········{
83 ············m.Hinzufuegen( r );··// Cannot add transient object
84 ············var thrown = false;
85 ············try
86 ············{
87 ················pm.MakePersistent( m );
88 ············}
89 ············catch (NDOException)
90 ············{
91 ················thrown = true;
92 ············}
93 ············Assert.That(true ==··thrown );
94 ········}
95
96 ········[Test]
97 ········public void TestCreateObjectsTransient2()
98 ········{
99 ············pm.MakePersistent( m );
100 ············var thrown = false;
101 ············try
102 ············{
103 ················m.Hinzufuegen( r );··// Cannot add transient object
104 ············}
105 ············catch (NDOException)
106 ············{
107 ················thrown = true;
108 ············}
109 ············Assert.That(true ==··thrown );
110 ········}
111
112 ········[Test]
113 ········public void TestCreateObjectsTransient3()
114 ········{
115 ············pm.MakePersistent( r );
116 ············pm.MakePersistent( m );
117 ············m.Hinzufuegen( r );
118 ········}
119
120 ········[Test]
121 ········public void TestCreateObjectsTransient4()
122 ········{
123 ············pm.MakePersistent( r );
124 ············m.Hinzufuegen( r );
125 ············pm.MakePersistent( m );
126 ········}
127
128 ········[Test]
129 ········public void TestCreateObjectsSave()
130 ········{
131 ············pm.MakePersistent( r );
132 ············m.Hinzufuegen( r );
133 ············pm.MakePersistent( m );
134 ············pm.Save();
135 ············Assert.That( !m.NDOObjectId.Equals( r.NDOObjectId ), "Ids should be different" );
136 ············m = (Mitarbeiter)pm.FindObject( m.NDOObjectId );
137 ············r = (Reisebüro)pm.FindObject( r.NDOObjectId );
138 ············Assert.That(m != null, "1. Mitarbeiter not found" );
139 ············Assert.That(r != null, "1. Reisebüro not found" );
140
141 ············pm.UnloadCache();
142 ············m = (Mitarbeiter)pm.FindObject( m.NDOObjectId );
143 ············r = (Reisebüro)pm.FindObject( r.NDOObjectId );
144 ············Assert.That(m != null, "2. Mitarbeiter not found" );
145 ············Assert.That(r != null, "2. Reisebüro not found" );
146 ········}
147
148 ········[Test]
149 ········public void TestQueryWithCondition()
150 ········{
151 ············pm.MakePersistent( r );
152 ············m.Hinzufuegen( r );
153 ············pm.MakePersistent( m );
154 ············pm.Save();
155
156 ············pm.UnloadCache();
157
158 ············var provider = pm.NDOMapping.FindClass( typeof( Mitarbeiter ) ).Provider;
159 ············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, $"reiseBüros.name LIKE 'L{provider.Wildcard}'" );
160 ············//System.Diagnostics.Debug.WriteLine(q.GeneratedQuery);
161 ············IList l = q.Execute();
162 ············Assert.That(1 ==··l.Count, "Mitarbeiter not found" );
163 ········}
164
165
166 ········[Test]
167 ········public void TestAddObjectSave()
168 ········{
169 ············StandardSetup();
170 ············pm.MakePersistent( m );
171 ············pm.Save();
172 ············m.Hinzufuegen( r );
173 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "1. Wrong state" );
174 ············pm.Save();
175 ············m = (Mitarbeiter)pm.FindObject( m.NDOObjectId );
176 ············r = (Reisebüro)pm.FindObject( r.NDOObjectId );
177 ············Assert.That(m != null, "1. Mitarbeiter not found" );
178 ············Assert.That(r != null, "1. Reisebüro not found" );
179 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "2. Wrong state" );
180 ········}
181
182 ········[Test]
183 ········public void TestAddObjectAbort()
184 ········{
185 ············StandardSetup();
186 ············pm.MakePersistent( m );
187 ············pm.Save();
188 ············m.Hinzufuegen( r );
189 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "1. Wrong state" );
190 ············Assert.That(1 ==··m.Reisebüros.Count, "1. Wrong number of objects" );
191 ············pm.Abort();
192 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "2. Wrong state" );
193 ············Assert.That(0 ==··m.Reisebüros.Count, "2. Wrong number of objects" );
194 ········}
195 ········[Test]
196 ········public void TestRemoveObjectSave()
197 ········{
198 ············StandardSetup();
199 ············m.Hinzufuegen( r );
200 ············pm.MakePersistent( m );
201 ············pm.Save();
202 ············Assert.That(1 ==··m.Reisebüros.Count, "1. Wrong number of objects" );
203 ············m.Löschen( r );
204 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "1. Wrong state" );
205 ············Assert.That(0 ==··m.Reisebüros.Count, "2. Wrong number of objects" );
206 ············pm.Save();
207 ············Assert.That(0 ==··m.Reisebüros.Count, "3. Wrong number of objects" );
208 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "2. Wrong state" );
209 ········}
210
211 ········[Test]
212 ········public void TestRemoveObjectAbort()
213 ········{
214 ············StandardSetup();
215 ············pm.MakePersistent( m );
216 ············m.Hinzufuegen( r );
217 ············pm.Save();
218 ············Assert.That(1 ==··m.Reisebüros.Count, "1. Wrong number of objects" );
219 ············m.Löschen( r );
220 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "1. Wrong state" );
221 ············Assert.That(0 ==··m.Reisebüros.Count, "2. Wrong number of objects" );
222 ············pm.Abort();
223 ············Assert.That(1 ==··m.Reisebüros.Count, "3. Wrong number of objects" );
224 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "2. Wrong state" );
225 ········}
226
227 ········[Test]
228 ········public void TestDeleteSave()
229 ········{
230 ············StandardSetup();
231 ············pm.MakePersistent( m );
232 ············m.Hinzufuegen( r );
233 ············pm.Save();
234 ············pm.Delete( m );
235 ············Assert.That(NDOObjectState.Deleted ==··m.NDOObjectState, "1. Wrong state" );
236 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "2. Wrong state" );
237 ············pm.Save();
238 ············Assert.That(NDOObjectState.Transient ==··m.NDOObjectState, "1. Wrong state" );
239 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "2. Wrong state" );
240 ········}
241
242
243
244 ········[Test]
245 ········public void TestDeleteAbort()
246 ········{
247 ············StandardSetup();
248 ············pm.MakePersistent( m );
249 ············m.Hinzufuegen( r );
250 ············pm.Save();
251 ············pm.Delete( m );
252 ············Assert.That(NDOObjectState.Deleted ==··m.NDOObjectState, "1. Wrong state" );
253 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "2. Wrong state" );
254 ············pm.Abort();
255 ············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "1. Wrong state" );
256 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "2. Wrong state" );
257 ········}
258
259 ········[Test]
260 ········public void TestAddRemoveSave()
261 ········{
262 ············StandardSetup();
263 ············pm.MakePersistent( m );
264 ············pm.Save();
265 ············m.Hinzufuegen( r );
266 ············m.Löschen( r );
267 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "1. Wrong state" );
268 ············pm.Save();
269 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "2. Wrong state" );
270 ············Assert.That(0 ==··m.Reisebüros.Count, "3. Wrong number of objects" );
271 ········}
272
273 ········[Test]
274 ········public void TestAddRemoveAbort()
275 ········{
276 ············StandardSetup();
277 ············pm.MakePersistent( m );
278 ············pm.Save();
279 ············m.Hinzufuegen( r );
280 ············m.Löschen( r );
281 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "1. Wrong state" );
282 ············pm.Abort();
283 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "2. Wrong state" );
284 ············Assert.That(0 ==··m.Reisebüros.Count, "3. Wrong number of objects" );
285 ········}
286
287 ········[Test]
288 ········public void TestClearRelatedObjectsSave()
289 ········{
290 ············for (int i = 0; i < 10; i++)
291 ············{
292 ················Reisebüro rb = CreateReisebüro( i.ToString() );
293 ················pm.MakePersistent( rb );
294 ················m.Hinzufuegen( rb );
295 ············}
296 ············pm.MakePersistent( m );
297 ············pm.Save();
298 ············IList rr = new ArrayList( m.Reisebüros );
299 ············m.LöscheReisebüros();
300 ············Assert.That(0 ==··m.Reisebüros.Count, "1. Wrong number of objects" );
301 ············for (int i = 0; i < 10; i++)
302 ············{
303 ················Assert.That(NDOObjectState.Persistent ==··((Reisebüro)rr[i]).NDOObjectState, "2. Wrong state" );
304 ············}
305 ············pm.Save();
306 ············Assert.That(0 ==··m.Reisebüros.Count, "3. Wrong number of objects" );
307 ············for (int i = 0; i < 10; i++)
308 ············{
309 ················Assert.That(NDOObjectState.Persistent ==··((Reisebüro)rr[i]).NDOObjectState, "4. Wrong state" );
310 ············}
311 ········}
312
313 ········[Test]
314 ········public void TestClearRelatedObjectsAbort()
315 ········{
316 ············for (int i = 0; i < 10; i++)
317 ············{
318 ················Reisebüro rb = CreateReisebüro( i.ToString() );
319 ················pm.MakePersistent( rb );
320 ················m.Hinzufuegen( rb );
321 ············}
322 ············pm.MakePersistent( m );
323 ············pm.Save();
324 ············IList rr = new ArrayList( m.Reisebüros );
325 ············m.LöscheReisebüros();
326 ············Assert.That(0 ==··m.Reisebüros.Count, "1. Wrong number of objects" );
327 ············for (int i = 0; i < 10; i++)
328 ············{
329 ················Assert.That(NDOObjectState.Persistent ==··((Reisebüro)rr[i]).NDOObjectState, "2. Wrong state" );
330 ············}
331 ············pm.Abort();
332 ············Assert.That(10 ==··m.Reisebüros.Count, "3. Wrong number of objects" );
333 ············for (int i = 0; i < 10; i++)
334 ············{
335 ················Assert.That(NDOObjectState.Persistent ==··((Reisebüro)rr[i]).NDOObjectState, "4. Wrong state" );
336 ············}
337 ········}
338
339
340 ········[Test]
341 ········public void TestHollow()
342 ········{
343 ············StandardSetup();
344 ············m.Hinzufuegen( r );
345 ············pm.MakePersistent( m );
346 ············pm.Save();
347 ············pm.MakeHollow( m );
348 ············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "1: Mitarbeiter should be hollow" );
349 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "1: Reisebüro should be persistent" );
350 ············IList Reisebüro = m.Reisebüros;
351
352 ············pm.MakeHollow( m, true );
353 ············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "2: Mitarbeiter should be hollow" );
354 ············Assert.That(NDOObjectState.Hollow ==··r.NDOObjectState, "2: Reisebüro should be hollow" );
355
356 ············Reisebüro = m.Reisebüros;
357 ············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "3: Mitarbeiter should be persistent" );
358 ············Assert.That(NDOObjectState.Hollow ==··r.NDOObjectState, "3: Reisebüro should be hollow" );
359 ············Assert.That("Lufthansa City Center" ==··r.Name, "3: Reisebüro should have correct Name" );
360 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "4: Reisebüro should be persistent" );
361 ········}
362
363 ········[Test]
364 ········public void TestMakeAllHollow()
365 ········{
366 ············StandardSetup();
367 ············m.Hinzufuegen( r );
368 ············pm.MakePersistent( m );
369 ············pm.Save();
370 ············pm.MakeAllHollow();
371 ············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "1: Mitarbeiter should be hollow" );
372 ············Assert.That(NDOObjectState.Hollow ==··r.NDOObjectState, "1: Reisebüro should be hollow" );
373 ········}
374
375 ········[Test]
376 ········public void TestMakeAllHollowUnsaved()
377 ········{
378 ············StandardSetup();
379 ············m.Hinzufuegen( r );
380 ············pm.MakePersistent( m );
381 ············pm.MakeAllHollow();··// before save, objects cannot be made hollow. => in locked objects
382 ············Assert.That(NDOObjectState.Created ==··m.NDOObjectState, "1: Mitarbeiter should be created" );
383 ············Assert.That(NDOObjectState.Hollow ==··r.NDOObjectState, "1: Reisebüro should be Persistent" );
384 ········}
385
386 ········[Test]
387 ········public void TestLoadRelatedObjects()
388 ········{
389 ············for (int i = 0; i < 10; i++)
390 ············{
391 ················Reisebüro rb = CreateReisebüro( i.ToString() );
392 ················pm.MakePersistent( rb );
393 ················m.Hinzufuegen( rb );
394 ············}
395 ············pm.MakePersistent( m );
396 ············pm.Save();
397 ············pm.MakeHollow( m, true );
398
399 ············IList Reisebüros = new ArrayList( m.Reisebüros );
400 ············Assert.That(10 ==··Reisebüros.Count, "List size should be 10" );
401
402 ············for (int i = 0; i < 10; i++)
403 ············{
404 ················Reisebüro rr = (Reisebüro)Reisebüros[i];
405 ················Assert.That(NDOObjectState.Hollow ==··rr.NDOObjectState, "1: Reisebüro should be hollow" );
406 #if !ORACLE && !MYSQL && !FIREBIRD
407 ················Assert.That(i.ToString() ==··rr.Name, "2: Reisebüro should be in right order" );
408 #endif
409 ············}
410
411
412 ············pm.MakeAllHollow();
413 ············pm.UnloadCache();
414 ············IList Reisebüros2 = m.Reisebüros;
415 ············for (int i = 0; i < 10; i++)
416 ············{
417 ················Reisebüro r1 = (Reisebüro)Reisebüros[i];
418 ················Reisebüro r2 = (Reisebüro)Reisebüros2[i];
419 #if !ORACLE && !MYSQL && !FIREBIRD
420 ················Assert.That(i.ToString() ==··r1.Name, "3: Reisebüro should be in right order" );
421 #endif
422 ················Assert.That( r1 != r2, "Objects should be different" );
423 ············}
424 ········}
425
426 ········[Test]
427 ········public void TestLoadRelatedObjectsSave()
428 ········{
429 ············pm.MakePersistent( m );
430 ············pm.Save();
431 ············for (int i = 0; i < 10; i++)
432 ············{
433 ················Reisebüro rb = CreateReisebüro( i.ToString() );
434 ················pm.MakePersistent( rb );
435 ················m.Hinzufuegen( rb );
436 ············}
437 ············pm.Save();
438 ············pm.MakeHollow( m, true );
439
440 ············IList Reisebüros = new ArrayList( m.Reisebüros );
441
442 ············for (int i = 0; i < 10; i++)
443 ············{
444 ················Reisebüro rr = (Reisebüro)Reisebüros[i];
445 ················Assert.That(NDOObjectState.Hollow ==··rr.NDOObjectState, "1: Reisebüro should be hollow" );
446 #if !ORACLE && !MYSQL && !FIREBIRD
447 ················Assert.That(i.ToString() ==··rr.Name, "2: Reisebüro should be in right order" );
448 #endif
449 ············}
450
451
452 ············pm.MakeAllHollow();
453 ············pm.UnloadCache();
454 ············IList Reisebüros2 = m.Reisebüros;
455 ············for (int i = 0; i < 10; i++)
456 ············{
457 ················Reisebüro r1 = (Reisebüro)Reisebüros[i];
458 ················Reisebüro r2 = (Reisebüro)Reisebüros2[i];
459 #if !ORACLE && !MYSQL && !FIREBIRD
460 ················Assert.That(i.ToString() ==··r1.Name, "3: Reisebüro should be in right order" );
461 #endif
462 ················Assert.That( r1 != r2, "Objects should be different" );
463 ············}
464 ········}
465
466 ········[Test]
467 ········public void TestExtentRelatedObjects()
468 ········{
469 ············StandardSetup();
470 ············m.Hinzufuegen( r );
471 ············pm.MakePersistent( m );
472 ············pm.Save();
473 ············IList liste = pm.GetClassExtent( typeof( Mitarbeiter ) );
474 ············m = (Mitarbeiter)liste[0];
475 ············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "1: Mitarbeiter should be persistent" );
476 ············Assert.That(m.Reisebüros != null, "2. Relation is missing" );
477 ············Assert.That(1 ==··m.Reisebüros.Count, "3. Wrong number of objects" );
478 ············Assert.That(NDOObjectState.Persistent ==··((Reisebüro)m.Reisebüros[0]).NDOObjectState, "4.: Reisebüro should be persistent" );
479
480 ············pm.UnloadCache();
481 ············liste = pm.GetClassExtent( typeof( Mitarbeiter ) );
482 ············m = (Mitarbeiter)liste[0];
483 ············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "5: Mitarbeiter should be hollow" );
484 ············Assert.That(m.Reisebüros != null, "6. Relation is missing" );
485 ············Assert.That(1 ==··m.Reisebüros.Count, "7. Wrong number of objects" );
486 ············Assert.That(NDOObjectState.Hollow ==··((Reisebüro)m.Reisebüros[0]).NDOObjectState, "8.: Reisebüro should be hollow" );
487
488 ············pm.UnloadCache();
489 ············liste = pm.GetClassExtent( typeof( Mitarbeiter ), false );
490 ············m = (Mitarbeiter)liste[0];
491 ············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "9: Mitarbeiter should be persistent" );
492 ············Assert.That(m.Reisebüros != null, "10. Relation is missing" );
493 ············Assert.That(1 ==··m.Reisebüros.Count, "11. Wrong number of objects" );
494 ············Assert.That(NDOObjectState.Hollow ==··((Reisebüro)m.Reisebüros[0]).NDOObjectState, "12.: Reisebüro should be hollow" );
495 ········}
496
497 ········private Mitarbeiter CreateMitarbeiter( string vorname, string nachname )
498 ········{
499 ············Mitarbeiter m = new Mitarbeiter();
500 ············m.Vorname = vorname;
501 ············m.Nachname = nachname;
502 ············return m;
503 ········}
504
505 ········private Reisebüro CreateReisebüro( string name )
506 ········{
507 ············Reisebüro r = new Reisebüro();
508 ············r.Name = name;
509 ············return r;
510 ········}
511
512 ········public void StandardSetup()
513 ········{
514 ············pm.MakePersistent( r );
515 ············pm.Save();
516 ········}
517 ····}
518 }
519
New Commit (ab2cdbc)
1 //
2 // Copyright (c) 2002-2016 Mirko Matytschak
3 // (www.netdataobjects.de)
4 //
5 // Author: Mirko Matytschak
6 //
7 // Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
8 // documentation files (the "Software"), to deal in the Software without restriction, including without limitation
9 // the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
10 // Software, and to permit persons to whom the Software is furnished to do so, subject to the following
11 // conditions:
12
13 // The above copyright notice and this permission notice shall be included in all copies or substantial portions
14 // of the Software.
15 //
16 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
17 // TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
19 // CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
20 // DEALINGS IN THE SOFTWARE.
21
22
23 using System;
24 using System.Collections;
25 using NDO;
26 using NDO.Query;
27 using NUnit.Framework;
28 using Reisekosten;
29 using Reisekosten.Personal;
30
31 namespace NdoUnitTests
32 {
33 ····/// <summary>
34 ····/// This class contains all tests for 1:n directed relations with an intermediate mapping table.
35 ····/// </summary>
36 ····[TestFixture]
37 ····public class Rel1toNDirectedWTable : NDOTest
38 ····{
39
40 ········public Rel1toNDirectedWTable()
41 ········{
42 ········}
43
44 ········private PersistenceManager pm;
45 ········private Mitarbeiter m;
46 ········private Reisebüro r;
47 ········private Reisebüro r2;
48
49 ········[SetUp]
50 ········public void Setup()
51 ········{
52 ············pm = PmFactory.NewPersistenceManager();
53 ············m = CreateMitarbeiter( "Hartmut", "Kocher" );
54 ············r = CreateReisebüro( "Lufthansa City Center" );
55 ········}
56
57 ········[TearDown]
58 ········public void TearDown()
59 ········{
60 ············pm.Abort();
61 ············IList mitarbeiterListe = pm.GetClassExtent( typeof( Mitarbeiter ), false );
62 ············pm.Delete( mitarbeiterListe );
63 ············IList rbListe = pm.GetClassExtent( typeof( Reisebüro ), false );
64 ············pm.Delete( rbListe );
65 ············pm.Save();
66 ········}
67
68 ········[OneTimeTearDown]
69 ········public void OneTimeTearDown()
70 ········{
71 ············pm.Close();
72 ············pm = null;
73 ········}
74
75 ········[Test]
76 ········public void TestCreateObjects()
77 ········{
78 ············pm.MakePersistent( r );
79 ············if (r.NDOObjectId.Id[0] is Int32 && !pm.HasOwnerCreatedIds)
80 ················Assert.That((int)r.NDOObjectId.Id[0] == -1, "Reisebüro key wrong" );
81 ············Reisebüro r2 = (Reisebüro)pm.FindObject( r.NDOObjectId );
82 ············Assert.That(Object.ReferenceEquals(r, r2), "Reisebüros should match" );
83 ········}
84
85 ········[Test]
86 ········public void TestCreateObjectsTransient1()
87 ········{
88 ············m.Hinzufuegen( r );··// Cannot add transient object
89 ············var thrown = false;
90 ············try
91 ············{
92 ················pm.MakePersistent( m );
93 ············}
94 ············catch (NDOException)
95 ············{
96 ················thrown = true;
97 ············}
98 ············Assert.That(true ==··thrown );
99 ········}
100
101 ········[Test]
102 ········public void TestCreateObjectsTransient2()
103 ········{
104 ············pm.MakePersistent( m );
105 ············var thrown = false;
106 ············try
107 ············{
108 ················m.Hinzufuegen( r );··// Cannot add transient object
109 ············}
110 ············catch (NDOException)
111 ············{
112 ················thrown = true;
113 ············}
114 ············Assert.That(true ==··thrown );
115 ········}
116
117 ········[Test]
118 ········public void TestCreateObjectsTransient3()
119 ········{
120 ············pm.MakePersistent( r );
121 ············pm.MakePersistent( m );
122 ············m.Hinzufuegen( r );
123 ········}
124
125 ········[Test]
126 ········public void TestCreateObjectsTransient4()
127 ········{
128 ············pm.MakePersistent( r );
129 ············m.Hinzufuegen( r );
130 ············pm.MakePersistent( m );
131 ········}
132
133 ········[Test]
134 ········public void TestCreateObjectsSave()
135 ········{
136 ············pm.MakePersistent( r );
137 ············m.Hinzufuegen( r );
138 ············pm.MakePersistent( m );
139 ············pm.Save();
140 ············Assert.That( !m.NDOObjectId.Equals( r.NDOObjectId ), "Ids should be different" );
141 ············m = (Mitarbeiter)pm.FindObject( m.NDOObjectId );
142 ············r = (Reisebüro)pm.FindObject( r.NDOObjectId );
143 ············Assert.That(m != null, "1. Mitarbeiter not found" );
144 ············Assert.That(r != null, "1. Reisebüro not found" );
145
146 ············pm.UnloadCache();
147 ············m = (Mitarbeiter)pm.FindObject( m.NDOObjectId );
148 ············r = (Reisebüro)pm.FindObject( r.NDOObjectId );
149 ············Assert.That(m != null, "2. Mitarbeiter not found" );
150 ············Assert.That(r != null, "2. Reisebüro not found" );
151 ········}
152
153 ········[Test]
154 ········public void TestQueryWithCondition()
155 ········{
156 ············pm.MakePersistent( r );
157 ············m.Hinzufuegen( r );
158 ············pm.MakePersistent( m );
159 ············pm.Save();
160
161 ············pm.UnloadCache();
162
163 ············var provider = pm.NDOMapping.FindClass( typeof( Mitarbeiter ) ).Provider;
164 ············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, $"reiseBüros.name LIKE 'L{provider.Wildcard}'" );
165 ············//System.Diagnostics.Debug.WriteLine(q.GeneratedQuery);
166 ············IList l = q.Execute();
167 ············Assert.That(1 ==··l.Count, "Mitarbeiter not found" );
168 ········}
169
170
171 ········[Test]
172 ········public void TestAddObjectSave()
173 ········{
174 ············StandardSetup();
175 ············pm.MakePersistent( m );
176 ············pm.Save();
177 ············m.Hinzufuegen( r );
178 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "1. Wrong state" );
179 ············pm.Save();
180 ············m = (Mitarbeiter)pm.FindObject( m.NDOObjectId );
181 ············r = (Reisebüro)pm.FindObject( r.NDOObjectId );
182 ············Assert.That(m != null, "1. Mitarbeiter not found" );
183 ············Assert.That(r != null, "1. Reisebüro not found" );
184 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "2. Wrong state" );
185 ········}
186
187 ········[Test]
188 ········public void TestAddObjectAbort()
189 ········{
190 ············StandardSetup();
191 ············pm.MakePersistent( m );
192 ············pm.Save();
193 ············m.Hinzufuegen( r );
194 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "1. Wrong state" );
195 ············Assert.That(1 ==··m.Reisebüros.Count, "1. Wrong number of objects" );
196 ············pm.Abort();
197 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "2. Wrong state" );
198 ············Assert.That(0 ==··m.Reisebüros.Count, "2. Wrong number of objects" );
199 ········}
200 ········[Test]
201 ········public void TestRemoveObjectSave()
202 ········{
203 ············StandardSetup();
204 ············m.Hinzufuegen( r );
205 ············pm.MakePersistent( m );
206 ············pm.Save();
207 ············Assert.That(1 ==··m.Reisebüros.Count, "1. Wrong number of objects" );
208 ············m.Löschen( r );
209 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "1. Wrong state" );
210 ············Assert.That(0 ==··m.Reisebüros.Count, "2. Wrong number of objects" );
211 ············pm.Save();
212 ············Assert.That(0 ==··m.Reisebüros.Count, "3. Wrong number of objects" );
213 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "2. Wrong state" );
214 ········}
215
216 ········[Test]
217 ········public void TestRemoveObjectAbort()
218 ········{
219 ············StandardSetup();
220 ············pm.MakePersistent( m );
221 ············m.Hinzufuegen( r );
222 ············pm.Save();
223 ············Assert.That(1 ==··m.Reisebüros.Count, "1. Wrong number of objects" );
224 ············m.Löschen( r );
225 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "1. Wrong state" );
226 ············Assert.That(0 ==··m.Reisebüros.Count, "2. Wrong number of objects" );
227 ············pm.Abort();
228 ············Assert.That(1 ==··m.Reisebüros.Count, "3. Wrong number of objects" );
229 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "2. Wrong state" );
230 ········}
231
232 ········[Test]
233 ········public void TestDeleteSave()
234 ········{
235 ············StandardSetup();
236 ············pm.MakePersistent( m );
237 ············m.Hinzufuegen( r );
238 ············pm.Save();
239 ············pm.Delete( m );
240 ············Assert.That(NDOObjectState.Deleted ==··m.NDOObjectState, "1. Wrong state" );
241 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "2. Wrong state" );
242 ············pm.Save();
243 ············Assert.That(NDOObjectState.Transient ==··m.NDOObjectState, "1. Wrong state" );
244 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "2. Wrong state" );
245 ········}
246
247
248
249 ········[Test]
250 ········public void TestDeleteAbort()
251 ········{
252 ············StandardSetup();
253 ············pm.MakePersistent( m );
254 ············m.Hinzufuegen( r );
255 ············pm.Save();
256 ············pm.Delete( m );
257 ············Assert.That(NDOObjectState.Deleted ==··m.NDOObjectState, "1. Wrong state" );
258 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "2. Wrong state" );
259 ············pm.Abort();
260 ············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "1. Wrong state" );
261 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "2. Wrong state" );
262 ········}
263
264 ········[Test]
265 ········public void TestAddRemoveSave()
266 ········{
267 ············StandardSetup();
268 ············pm.MakePersistent( m );
269 ············pm.Save();
270 ············m.Hinzufuegen( r );
271 ············m.Löschen( r );
272 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "1. Wrong state" );
273 ············pm.Save();
274 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "2. Wrong state" );
275 ············Assert.That(0 ==··m.Reisebüros.Count, "3. Wrong number of objects" );
276 ········}
277
278 ········[Test]
279 ········public void TestAddRemoveAbort()
280 ········{
281 ············StandardSetup();
282 ············pm.MakePersistent( m );
283 ············pm.Save();
284 ············m.Hinzufuegen( r );
285 ············m.Löschen( r );
286 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "1. Wrong state" );
287 ············pm.Abort();
288 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "2. Wrong state" );
289 ············Assert.That(0 ==··m.Reisebüros.Count, "3. Wrong number of objects" );
290 ········}
291
292 ········[Test]
293 ········public void TestClearRelatedObjectsSave()
294 ········{
295 ············for (int i = 0; i < 10; i++)
296 ············{
297 ················Reisebüro rb = CreateReisebüro( i.ToString() );
298 ················pm.MakePersistent( rb );
299 ················m.Hinzufuegen( rb );
300 ············}
301 ············pm.MakePersistent( m );
302 ············pm.Save();
303 ············IList rr = new ArrayList( m.Reisebüros );
304 ············m.LöscheReisebüros();
305 ············Assert.That(0 ==··m.Reisebüros.Count, "1. Wrong number of objects" );
306 ············for (int i = 0; i < 10; i++)
307 ············{
308 ················Assert.That(NDOObjectState.Persistent ==··((Reisebüro)rr[i]).NDOObjectState, "2. Wrong state" );
309 ············}
310 ············pm.Save();
311 ············Assert.That(0 ==··m.Reisebüros.Count, "3. Wrong number of objects" );
312 ············for (int i = 0; i < 10; i++)
313 ············{
314 ················Assert.That(NDOObjectState.Persistent ==··((Reisebüro)rr[i]).NDOObjectState, "4. Wrong state" );
315 ············}
316 ········}
317
318 ········[Test]
319 ········public void TestClearRelatedObjectsAbort()
320 ········{
321 ············for (int i = 0; i < 10; i++)
322 ············{
323 ················Reisebüro rb = CreateReisebüro( i.ToString() );
324 ················pm.MakePersistent( rb );
325 ················m.Hinzufuegen( rb );
326 ············}
327 ············pm.MakePersistent( m );
328 ············pm.Save();
329 ············IList rr = new ArrayList( m.Reisebüros );
330 ············m.LöscheReisebüros();
331 ············Assert.That(0 ==··m.Reisebüros.Count, "1. Wrong number of objects" );
332 ············for (int i = 0; i < 10; i++)
333 ············{
334 ················Assert.That(NDOObjectState.Persistent ==··((Reisebüro)rr[i]).NDOObjectState, "2. Wrong state" );
335 ············}
336 ············pm.Abort();
337 ············Assert.That(10 ==··m.Reisebüros.Count, "3. Wrong number of objects" );
338 ············for (int i = 0; i < 10; i++)
339 ············{
340 ················Assert.That(NDOObjectState.Persistent ==··((Reisebüro)rr[i]).NDOObjectState, "4. Wrong state" );
341 ············}
342 ········}
343
344
345 ········[Test]
346 ········public void TestHollow()
347 ········{
348 ············StandardSetup();
349 ············m.Hinzufuegen( r );
350 ············pm.MakePersistent( m );
351 ············pm.Save();
352 ············pm.MakeHollow( m );
353 ············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "1: Mitarbeiter should be hollow" );
354 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "1: Reisebüro should be persistent" );
355 ············IList Reisebüro = m.Reisebüros;
356
357 ············pm.MakeHollow( m, true );
358 ············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "2: Mitarbeiter should be hollow" );
359 ············Assert.That(NDOObjectState.Hollow ==··r.NDOObjectState, "2: Reisebüro should be hollow" );
360
361 ············Reisebüro = m.Reisebüros;
362 ············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "3: Mitarbeiter should be persistent" );
363 ············Assert.That(NDOObjectState.Hollow ==··r.NDOObjectState, "3: Reisebüro should be hollow" );
364 ············Assert.That("Lufthansa City Center" ==··r.Name, "3: Reisebüro should have correct Name" );
365 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "4: Reisebüro should be persistent" );
366 ········}
367
368 ········[Test]
369 ········public void TestMakeAllHollow()
370 ········{
371 ············StandardSetup();
372 ············m.Hinzufuegen( r );
373 ············pm.MakePersistent( m );
374 ············pm.Save();
375 ············pm.MakeAllHollow();
376 ············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "1: Mitarbeiter should be hollow" );
377 ············Assert.That(NDOObjectState.Hollow ==··r.NDOObjectState, "1: Reisebüro should be hollow" );
378 ········}
379
380 ········[Test]
381 ········public void TestMakeAllHollowUnsaved()
382 ········{
383 ············StandardSetup();
384 ············m.Hinzufuegen( r );
385 ············pm.MakePersistent( m );
386 ············pm.MakeAllHollow();··// before save, objects cannot be made hollow. => in locked objects
387 ············Assert.That(NDOObjectState.Created ==··m.NDOObjectState, "1: Mitarbeiter should be created" );
388 ············Assert.That(NDOObjectState.Hollow ==··r.NDOObjectState, "1: Reisebüro should be Persistent" );
389 ········}
390
391 ········[Test]
392 ········public void TestLoadRelatedObjects()
393 ········{
394 ············for (int i = 0; i < 10; i++)
395 ············{
396 ················Reisebüro rb = CreateReisebüro( i.ToString() );
397 ················pm.MakePersistent( rb );
398 ················m.Hinzufuegen( rb );
399 ············}
400 ············pm.MakePersistent( m );
401 ············pm.Save();
402 ············pm.MakeHollow( m, true );
403
404 ············IList Reisebüros = new ArrayList( m.Reisebüros );
405 ············Assert.That(10 ==··Reisebüros.Count, "List size should be 10" );
406
407 ············for (int i = 0; i < 10; i++)
408 ············{
409 ················Reisebüro rr = (Reisebüro)Reisebüros[i];
410 ················Assert.That(NDOObjectState.Hollow ==··rr.NDOObjectState, "1: Reisebüro should be hollow" );
411 #if !ORACLE && !MYSQL && !FIREBIRD
412 ················Assert.That(i.ToString() ==··rr.Name, "2: Reisebüro should be in right order" );
413 #endif
414 ············}
415
416
417 ············pm.MakeAllHollow();
418 ············pm.UnloadCache();
419 ············IList Reisebüros2 = m.Reisebüros;
420 ············for (int i = 0; i < 10; i++)
421 ············{
422 ················Reisebüro r1 = (Reisebüro)Reisebüros[i];
423 ················Reisebüro r2 = (Reisebüro)Reisebüros2[i];
424 #if !ORACLE && !MYSQL && !FIREBIRD
425 ················Assert.That(i.ToString() ==··r1.Name, "3: Reisebüro should be in right order" );
426 #endif
427 ················Assert.That( r1 != r2, "Objects should be different" );
428 ············}
429 ········}
430
431 ········[Test]
432 ········public void TestLoadRelatedObjectsSave()
433 ········{
434 ············pm.MakePersistent( m );
435 ············pm.Save();
436 ············for (int i = 0; i < 10; i++)
437 ············{
438 ················Reisebüro rb = CreateReisebüro( i.ToString() );
439 ················pm.MakePersistent( rb );
440 ················m.Hinzufuegen( rb );
441 ············}
442 ············pm.Save();
443 ············pm.MakeHollow( m, true );
444
445 ············IList Reisebüros = new ArrayList( m.Reisebüros );
446
447 ············for (int i = 0; i < 10; i++)
448 ············{
449 ················Reisebüro rr = (Reisebüro)Reisebüros[i];
450 ················Assert.That(NDOObjectState.Hollow ==··rr.NDOObjectState, "1: Reisebüro should be hollow" );
451 #if !ORACLE && !MYSQL && !FIREBIRD
452 ················Assert.That(i.ToString() ==··rr.Name, "2: Reisebüro should be in right order" );
453 #endif
454 ············}
455
456
457 ············pm.MakeAllHollow();
458 ············pm.UnloadCache();
459 ············IList Reisebüros2 = m.Reisebüros;
460 ············for (int i = 0; i < 10; i++)
461 ············{
462 ················Reisebüro r1 = (Reisebüro)Reisebüros[i];
463 ················Reisebüro r2 = (Reisebüro)Reisebüros2[i];
464 #if !ORACLE && !MYSQL && !FIREBIRD
465 ················Assert.That(i.ToString() ==··r1.Name, "3: Reisebüro should be in right order" );
466 #endif
467 ················Assert.That( r1 != r2, "Objects should be different" );
468 ············}
469 ········}
470
471 ········[Test]
472 ········public void TestExtentRelatedObjects()
473 ········{
474 ············StandardSetup();
475 ············m.Hinzufuegen( r );
476 ············pm.MakePersistent( m );
477 ············pm.Save();
478 ············IList liste = pm.GetClassExtent( typeof( Mitarbeiter ) );
479 ············m = (Mitarbeiter)liste[0];
480 ············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "1: Mitarbeiter should be persistent" );
481 ············Assert.That(m.Reisebüros != null, "2. Relation is missing" );
482 ············Assert.That(1 ==··m.Reisebüros.Count, "3. Wrong number of objects" );
483 ············Assert.That(NDOObjectState.Persistent ==··((Reisebüro)m.Reisebüros[0]).NDOObjectState, "4.: Reisebüro should be persistent" );
484
485 ············pm.UnloadCache();
486 ············liste = pm.GetClassExtent( typeof( Mitarbeiter ) );
487 ············m = (Mitarbeiter)liste[0];
488 ············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "5: Mitarbeiter should be hollow" );
489 ············Assert.That(m.Reisebüros != null, "6. Relation is missing" );
490 ············Assert.That(1 ==··m.Reisebüros.Count, "7. Wrong number of objects" );
491 ············Assert.That(NDOObjectState.Hollow ==··((Reisebüro)m.Reisebüros[0]).NDOObjectState, "8.: Reisebüro should be hollow" );
492
493 ············pm.UnloadCache();
494 ············liste = pm.GetClassExtent( typeof( Mitarbeiter ), false );
495 ············m = (Mitarbeiter)liste[0];
496 ············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "9: Mitarbeiter should be persistent" );
497 ············Assert.That(m.Reisebüros != null, "10. Relation is missing" );
498 ············Assert.That(1 ==··m.Reisebüros.Count, "11. Wrong number of objects" );
499 ············Assert.That(NDOObjectState.Hollow ==··((Reisebüro)m.Reisebüros[0]).NDOObjectState, "12.: Reisebüro should be hollow" );
500 ········}
501
502 ········private Mitarbeiter CreateMitarbeiter( string vorname, string nachname )
503 ········{
504 ············Mitarbeiter m = new Mitarbeiter();
505 ············m.Vorname = vorname;
506 ············m.Nachname = nachname;
507 ············return m;
508 ········}
509
510 ········private Reisebüro CreateReisebüro( string name )
511 ········{
512 ············Reisebüro r = new Reisebüro();
513 ············r.Name = name;
514 ············return r;
515 ········}
516
517 ········public void StandardSetup()
518 ········{
519 ············pm.MakePersistent( r );
520 ············pm.Save();
521 ········}
522 ····}
523 }
524