Datei: IntegrationTests/IntegrationTests/NDOMitarbeiterReiseTests.cs

Last Commit (182cfd7)
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.Linq;
25 using System.Reflection;
26 using System.Collections;
27 using System.Collections.Generic;
28 using NUnit.Framework;
29 using NDO;
30 using NDO.Query;
31 using Reisekosten;
32 using Reisekosten.Personal;
33 using NDO.Linq;
34 using NDO.Mapping;
35 using Microsoft.Extensions.DependencyInjection;
36
37 namespace NdoUnitTests
38 {
39 ····/// <summary>
40 ····/// Combined Tests of Mitarbeiter and Reise to test uniqueness of object ids.
41 ····/// </summary>
42 ····[TestFixture]
43 ····public class NDOMitarbeiterReiseTests : NDOTest
44 ····{
45 ········public NDOMitarbeiterReiseTests()
46 ········{
47 ········}
48
49 ········private PersistenceManager pm;
50 ········private Mitarbeiter m;
51 ········private Reise r;
52
53 ········[SetUp]
54 ········public void Setup() {
55 ············pm = PmFactory.NewPersistenceManager();
56 ············m = CreateMitarbeiter("Hartmut", "Kocher");
57 ············r = CreateReise("ADC");
58 ········}
59
60 ········[TearDown]
61 ········public void TearDown() {
62 ············pm.Abort();
63 ············pm.UnloadCache();
64 ············var mitarbeiterListe = pm.Objects<Mitarbeiter>().ResultTable;
65 ············pm.Delete(mitarbeiterListe);
66 ············pm.Save();
67 ············pm.Objects<Reise>().DeleteDirectly();
68 ············pm.Close();
69 ············pm.Dispose();
70 ········}
71
72 ········[Test]
73 ········public void TestCreateObjects() {
74 ············pm.MakePersistent(m);
75 ············pm.MakePersistent(r);
76 ············Assert.That(!m.NDOObjectId.Equals(r.NDOObjectId), "Ids should be different");
77 ············m = (Mitarbeiter)pm.FindObject(m.NDOObjectId);
78 ············r = (Reise)pm.FindObject(r.NDOObjectId);
79 ········}
80
81 ········[Test]
82 ········public void TestCreateObjectsSave() {
83 ············m.Hinzufuegen(r);
84 ············pm.MakePersistent(m);
85 ············pm.Save();
86 ············Assert.That(!m.NDOObjectId.Equals(r.NDOObjectId), "Ids should be different");
87 ············m = (Mitarbeiter)pm.FindObject(m.NDOObjectId);
88 ············r = (Reise)pm.FindObject(r.NDOObjectId);
89 ············Assert.That(m != null, "1. Mitarbeiter not found");
90 ············Assert.That(r != null, "1. Reise not found");
91
92 ············pm.UnloadCache();
93 ············m = (Mitarbeiter)pm.FindObject(m.NDOObjectId);
94 ············r = (Reise)pm.FindObject(r.NDOObjectId);
95 ············Assert.That(m != null, "2. Mitarbeiter not found");
96 ············Assert.That(r != null, "2. Reise not found");
97 ········}
98
99 ········[Test]
100 ········public void TestAddObjectSave() {
101 ············pm.MakePersistent(m);
102 ············pm.Save();
103 ············m.Hinzufuegen(r);
104 ············Assert.That(NDOObjectState.Created ==··r.NDOObjectState, "1. Wrong state");
105 ············pm.Save();
106 ············m = (Mitarbeiter)pm.FindObject(m.NDOObjectId);
107 ············r = (Reise)pm.FindObject(r.NDOObjectId);
108 ············Assert.That(m != null, "1. Mitarbeiter not found");
109 ············Assert.That(r != null, "1. Reise not found");
110 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "2. Wrong state");
111 ········}
112
113 int GetOrdinal( Relation r)
114 ········{
115 var t = r. Parent. SystemType;
116 Type mcType = t. GetNestedType( "MetaClass", BindingFlags. NonPublic | BindingFlags. Public ) ;
117 if ( null == mcType)
118 ················throw new NDOException( 13, "Missing nested class 'MetaClass' for type '" + t.Name + "'; the type doesn't seem to be enhanced." );
119 ············var mc = (IMetaClass2)Activator.CreateInstance( mcType, t );
120 ············return mc.GetRelationOrdinal( r.FieldName );
121 ········}
122
123 ········bool IsLoaded(IPersistentObject pc, Relation r)
124 ········{
125 ············return ((IPersistenceCapable)pc).NDOLoadState.RelationLoadState[GetOrdinal( r )];
126 ········}
127
128 ········[Test]
129 ········public void RestorePreservesRelationLists()
130 ········{
131 ············pm.MakePersistent( m );
132 ············pm.Save();
133 ············m.Hinzufuegen( r );
134 ············pm.Save();
135 ············Assert.That(1 ==··m.Reisen.Count );
136
137 ············pm.UnloadCache();
138 ············var m2 = pm.Objects<Mitarbeiter>().Single();
139
140 ············var relation = pm.NDOMapping.FindClass( typeof( Mitarbeiter ) ).FindRelation( "dieReisen" );
141
142 ············Assert.That( !IsLoaded( m2, relation ) );
143 ············var list = m2.Reisen;
144 ············m2.Vorname = "Testxxxx";
145
146 ············Assert.That( IsLoaded( m2, relation ) );
147
148 ············pm.Restore( m2 );
149 ············m2.Nachname = "Testyyyy";
150 ············pm.Save();
151
152
153 ············Assert.That(1 ==··m2.Reisen.Count );
154 ········}
155
156 ········[Test]
157 ········public void TestAddObjectAbort() {
158 ············pm.MakePersistent(m);
159 ············pm.Save();
160 ············m.Hinzufuegen(r);
161 ············Assert.That(NDOObjectState.Created ==··r.NDOObjectState, "1. Wrong state");
162 ············Assert.That(1 ==··m.Reisen.Count, "1. Wrong number of objects");
163 ············pm.Abort();
164 ············Assert.That(NDOObjectState.Transient ==··r.NDOObjectState, "2. Wrong state");
165 ············Assert.That(0 ==··m.Reisen.Count, "2. Wrong number of objects");
166 ········}
167 ········[Test]
168 ········public void TestRemoveObjectSave() {
169 ············pm.MakePersistent(m);
170 ············m.Hinzufuegen(r);
171 ············pm.Save();
172 ············Assert.That(1 ==··m.Reisen.Count, "1. Wrong number of objects");
173 ············m.Löschen(r);
174 ············Assert.That(NDOObjectState.Deleted ==··r.NDOObjectState, "1. Wrong state");
175 ············Assert.That(0 ==··m.Reisen.Count, "2. Wrong number of objects");
176 ············pm.Save();
177 ············Assert.That(0 ==··m.Reisen.Count, "3. Wrong number of objects");
178 ············Assert.That(NDOObjectState.Transient ==··r.NDOObjectState, "2. Wrong state");
179 ········}
180 ············
181 ········[Test]
182 ········public void TestRemoveObjectAbort() {
183 ············pm.MakePersistent(m);
184 ············m.Hinzufuegen(r);
185 ············pm.Save();
186 ············Assert.That(1 ==··m.Reisen.Count, "1. Wrong number of objects");
187 ············m.Löschen(r);
188 ············Assert.That(NDOObjectState.Deleted ==··r.NDOObjectState, "1. Wrong state");
189 ············Assert.That(0 ==··m.Reisen.Count, "2. Wrong number of objects");
190 ············pm.Abort();
191 ············Assert.That(1 ==··m.Reisen.Count, "3. Wrong number of objects");
192 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "2. Wrong state");
193 ········}
194
195 ········[Test]
196 ········public void TestDeleteSave() {
197 ············pm.MakePersistent(m);
198 ············m.Hinzufuegen(r);
199 ············pm.Save();
200 ············pm.Delete(m);
201 ············Assert.That(NDOObjectState.Deleted ==··m.NDOObjectState, "1. Wrong state");
202 ············Assert.That(NDOObjectState.Deleted ==··r.NDOObjectState, "2. Wrong state");
203 ············pm.Save();
204 ············Assert.That(NDOObjectState.Transient ==··m.NDOObjectState, "1. Wrong state");
205 ············Assert.That(NDOObjectState.Transient ==··r.NDOObjectState, "2. Wrong state");
206 ········}
207
208
209
210 ········[Test]
211 ········public void TestDeleteAbort() {
212 ············pm.MakePersistent(m);
213 ············m.Hinzufuegen(r);
214 ············pm.Save();
215 ············pm.Delete(m);
216 ············Assert.That(NDOObjectState.Deleted ==··m.NDOObjectState, "1. Wrong state");
217 ············Assert.That(NDOObjectState.Deleted ==··r.NDOObjectState, "2. Wrong state");
218 ············pm.Abort();
219 ············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "1. Wrong state");
220 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "2. Wrong state");
221 ········}
222
223 ········[Test]
224 ········public void TestAddRemoveSave() {
225 ············pm.MakePersistent(m);
226 ············pm.Save();
227 ············m.Hinzufuegen(r);
228 ············m.Löschen(r);
229 ············Assert.That(NDOObjectState.Transient ==··r.NDOObjectState, "1. Wrong state");
230 ············pm.Save();
231 ············Assert.That(NDOObjectState.Transient ==··r.NDOObjectState, "2. Wrong state");
232 ········}
233
234 ········[Test]
235 ········public void TestAddRemoveAbort() {
236 ············pm.MakePersistent(m);
237 ············pm.Save();
238 ············m.Hinzufuegen(r);
239 ············m.Löschen(r);
240 ············Assert.That(NDOObjectState.Transient ==··r.NDOObjectState, "1. Wrong state");
241 ············pm.Abort();
242 ············Assert.That(NDOObjectState.Transient ==··r.NDOObjectState, "2. Wrong state");
243 ········}
244
245 ········[Test]
246 ········public void TestClearRelatedObjectsSave() {
247 ············for(int i = 0; i < 10; i++) {
248 ················m.Hinzufuegen(CreateReise(i.ToString()));
249 ············}
250 ············pm.MakePersistent(m);
251 ············pm.Save();
252 ············IList rr = new ArrayList(m.Reisen);
253 ············m.LöscheReisen();
254 ············Assert.That(0 ==··m.Reisen.Count, "1. Wrong number of objects");
255 ············for(int i = 0; i < 10; i++) {
256 ················Assert.That(NDOObjectState.Deleted ==··((Reise)rr[i]).NDOObjectState, "2. Wrong state");
257 ············}
258 ············pm.Save();
259 ············Assert.That(0 ==··m.Reisen.Count, "3. Wrong number of objects");
260 ············for(int i = 0; i < 10; i++) {
261 ················Assert.That(NDOObjectState.Transient ==··((Reise)rr[i]).NDOObjectState, "4. Wrong state");
262 ············}
263 ········}
264
265 ········[Test]
266 ········public void TestClearRelatedObjectsAbort() {
267 ············for(int i = 0; i < 10; i++) {
268 ················m.Hinzufuegen(CreateReise(i.ToString()));
269 ············}
270 ············pm.MakePersistent(m);
271 ············pm.Save();
272 ············IList rr = new ArrayList(m.Reisen);
273 ············m.LöscheReisen();
274 ············Assert.That(0 ==··m.Reisen.Count, "1. Wrong number of objects");
275 ············for(int i = 0; i < 10; i++) {
276 ················Assert.That(NDOObjectState.Deleted ==··((Reise)rr[i]).NDOObjectState, "2. Wrong state");
277 ············}
278 ············pm.Abort();
279 ············Assert.That(10 ==··m.Reisen.Count, "3. Wrong number of objects");
280 ············for(int i = 0; i < 10; i++) {
281 ················Assert.That(NDOObjectState.Persistent ==··((Reise)rr[i]).NDOObjectState, "4. Wrong state");
282 ············}
283 ········}
284
285 ········[Test]
286 ········public void TestAssignRelatedObjectsNullSave() {
287 ············for(int i = 0; i < 3; i++) {
288 ················m.Hinzufuegen(CreateReise(i.ToString()));
289 ············}
290 ············pm.MakePersistent(m);
291 ············pm.Save();
292 ············IList rr = new ArrayList(m.Reisen);
293 ············m.ErsetzeReisen(null);
294 ············Assert.That(m.Reisen == null, "No objects should be there");
295 ············for(int i = 0; i < 3; i++) {
296 ················Assert.That(NDOObjectState.Deleted ==··((Reise)rr[i]).NDOObjectState, "2. Wrong state");
297 ············}
298 ············pm.Save();
299 ············Assert.That(m.Reisen == null, "No objects should be there");
300 ············for(int i = 0; i < 3; i++) {
301 ················Assert.That(NDOObjectState.Transient ==··((Reise)rr[i]).NDOObjectState, "4. Wrong state");
302 ············}
303 ········}
304
305 ········[Test]
306 ········public void TestAssignRelatedObjectsNullAbort() {
307 ············for(int i = 0; i < 3; i++) {
308 ················m.Hinzufuegen(CreateReise(i.ToString()));
309 ············}
310 ············pm.MakePersistent(m);
311 ············pm.Save();
312 ············IList rr = new ArrayList(m.Reisen);
313 ············m.ErsetzeReisen(null);
314 ············Assert.That(m.Reisen == null, "No objects should be there");
315 ············for(int i = 0; i < 3; i++) {
316 ················Assert.That(NDOObjectState.Deleted ==··((Reise)rr[i]).NDOObjectState, "2. Wrong state");
317 ············}
318 ············pm.Abort();
319 ············Assert.That(3 ==··m.Reisen.Count, "3. Wrong number of objects");
320 ············for(int i = 0; i < 3; i++) {
321 ················Assert.That(NDOObjectState.Persistent ==··((Reise)rr[i]).NDOObjectState, "4. Wrong state");
322 ············}
323 ········}
324
325 ········[Test]
326 ········public void TestAssignRelatedObjectsSave() {
327 ············for(int i = 0; i < 3; i++) {
328 ················m.Hinzufuegen(CreateReise(i.ToString()));
329 ············}
330 ············pm.MakePersistent(m);
331 ············pm.Save();
332 ············IList neueReisen = new ArrayList();
333 ············Reise nr = CreateReise("Test");
334 ············neueReisen.Add(nr);
335
336 ············IList rr = new ArrayList(m.Reisen);
337 ············m.ErsetzeReisen(neueReisen);
338 ············Assert.That(1 ==··m.Reisen.Count, "1. Wrong number of objects");
339 ············for(int i = 0; i < 3; i++) {
340 ················Assert.That(NDOObjectState.Deleted ==··((Reise)rr[i]).NDOObjectState, "2. Wrong state");
341 ············}
342 ············Assert.That(NDOObjectState.Created ==··nr.NDOObjectState, "3. Wrong state");
343
344 ············pm.Save();
345 ············Assert.That(1 ==··m.Reisen.Count, "4. Wrong number of objects");
346 ············for(int i = 0; i < 3; i++) {
347 ················Assert.That(NDOObjectState.Transient ==··((Reise)rr[i]).NDOObjectState, "5. Wrong state");
348 ············}
349 ············Assert.That(NDOObjectState.Persistent ==··nr.NDOObjectState, "6. Wrong state");
350 ········}
351
352 ········[Test]
353 ········public void TestAssignRelatedObjectsAbort() {
354 ············for(int i = 0; i < 3; i++) {
355 ················m.Hinzufuegen(CreateReise(i.ToString()));
356 ············}
357 ············pm.MakePersistent(m);
358 ············pm.Save();
359 ············IList neueReisen = new ArrayList();
360 ············Reise nr = CreateReise("Test");
361 ············neueReisen.Add(nr);
362
363 ············IList rr = new ArrayList(m.Reisen);
364 ············m.ErsetzeReisen(neueReisen);
365 ············Assert.That(1 ==··m.Reisen.Count, "1. Wrong number of objects");
366 ············for(int i = 0; i < 3; i++) {
367 ················Assert.That(NDOObjectState.Deleted ==··((Reise)rr[i]).NDOObjectState, "2. Wrong state");
368 ············}
369 ············Assert.That(NDOObjectState.Created ==··nr.NDOObjectState, "3. Wrong state");
370
371 ············pm.Abort();
372 ············Assert.That(3 ==··m.Reisen.Count, "4. Wrong number of objects");
373 ············for(int i = 0; i < 3; i++) {
374 ················Assert.That(NDOObjectState.Persistent ==··((Reise)rr[i]).NDOObjectState, "5. Wrong state");
375 ············}
376 ············Assert.That(NDOObjectState.Transient ==··nr.NDOObjectState, "6. Wrong state");
377 ········}
378
379 ········[Test]
380 ········public void TestAddNewReise()
381 ········{
382 ············m.Hinzufuegen(r);
383 ············pm.MakePersistent(m);
384 ············pm.Save();
385 ············pm.UnloadCache();
386 ············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>(pm);
387 ············m = q.ExecuteSingle(true);
388 ············Reise r2 = CreateReise("Schnulli");
389 ············m.Hinzufuegen(r2);
390 ············pm.Save();
391 ············m = q.ExecuteSingle(true);
392 ············Assert.That(2 ==··m.Reisen.Count, "Count wrong");
393 ········}
394
395 ········[Test]
396 ········public void RefreshReloadsRelation()
397 ········{
398 ············m.Hinzufuegen( r );
399 ············pm.MakePersistent( m );
400 ············pm.Save();
401 ············PersistenceManager pm2 = PmFactory.NewPersistenceManager();
402 ············Mitarbeiter m2 = pm2.Objects<Mitarbeiter>().ResultTable.First();
403 ············Assert.That(m.Reisen.Count ==··m2.Reisen.Count );
404 ············Assert.That(1 ==··m.Reisen.Count );
405 ············Reise r2 = new Reise() { Zweck = "Test" };
406 ············m2.Hinzufuegen( r2 );
407 ············pm2.Save();
408 ············Assert.That(1 ==··m.Reisen.Count );
409 ············pm.Refresh( m );
410 ············Assert.That(2 ==··m.Reisen.Count );
411 ········}
412
413 ········[Test]
414 ········public void CanIterateThrougRelatedObjectsWithLinq()
415 ········{
416 ············m.Hinzufuegen( r );
417 ············r = new Reise() { Zweck = "Test" };
418 ············m.Hinzufuegen( r );
419 ············pm.MakePersistent( m );
420 ············pm.Save();
421 ············Assert.That(2 ==··m.Reisen.Count );
422 ············ObjectId oid = m.NDOObjectId;
423 ············pm.UnloadCache();
424 ············pm = PmFactory.NewPersistenceManager();
425 ············m = (Mitarbeiter) pm.FindObject( oid );
426 ············Assert.That( m.NDOObjectState == NDOObjectState.Hollow );
427 ············Reise tr = (from reise in m.Reisen where reise.Zweck == "Test" select reise).SingleOrDefault();
428 ············Assert.That(tr··!= null);
429 ············Assert.That("Test" ==··tr.Zweck );
430 ········}
431
432 ········[Test]
433 ········public void TestHollow() {
434 ············m.Hinzufuegen(r);
435 ············pm.MakePersistent(m);
436 ············pm.Save();
437 ············pm.MakeHollow(m);
438 ············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "1: Mitarbeiter should be hollow");
439 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "1: Reise should be persistent");
440 ············IList reise = m.Reisen;
441
442 ············pm.MakeHollow(m, true);
443 ············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "2: Mitarbeiter should be hollow");
444 ············Assert.That(NDOObjectState.Hollow ==··r.NDOObjectState, "2: Reise should be hollow");
445
446 ············reise = m.Reisen;
447 ············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "3: Mitarbeiter should be persistent");
448 ············Assert.That(NDOObjectState.Hollow ==··r.NDOObjectState, "3: Reise should be hollow");
449 ············Assert.That("ADC" ==··r.Zweck, "3: Reise should have correct Zweck");
450 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "4: Reise should be persistent");
451 ········}
452
453 ········[Test]
454 ········public void··TestMakeAllHollow() {
455 ············m.Hinzufuegen(r);
456 ············pm.MakePersistent(m);
457 ············pm.Save();
458 ············pm.MakeAllHollow();
459 ············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "1: Mitarbeiter should be hollow");
460 ············Assert.That(NDOObjectState.Hollow ==··r.NDOObjectState, "1: Reise should be hollow");
461 ············pm.UnloadCache();
462 ········}
463
464 ········[Test]
465 ········public void··TestMakeAllHollowUnsaved() {
466 ············m.Hinzufuegen(r);
467 ············pm.MakePersistent(m);
468 ············pm.MakeAllHollow();··// before save, objects cannot be made hollow. => in locked objects
469 ············Assert.That(NDOObjectState.Created ==··m.NDOObjectState, "1: Mitarbeiter should be created");
470 ············Assert.That(NDOObjectState.Created ==··r.NDOObjectState, "1: Reise should be created");
471 ········}
472
473 ········[Test]
474 ········public void TestLoadRelatedObjects() {
475 ············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>(pm, null);
476 ············IList dellist = q.Execute();
477 ············pm.Delete(dellist);
478 ············pm.Save();
479 ············pm.UnloadCache();
480
481 ············for(int i = 0; i < 10; i++) {
482 ················m.Hinzufuegen(CreateReise(i.ToString()));
483 ············}
484 ············pm.MakePersistent(m);
485 ············pm.Save();
486 ············pm.MakeHollow(m, true);
487
488 ············IList reisen = new ArrayList(m.Reisen);
489 ············Assert.That(10 ==··reisen.Count, "Array size should be 10");
490
491 ············for(int i = 0; i < 10; i++) {
492 ················Reise rr = (Reise)reisen[i];
493 ················Assert.That(NDOObjectState.Hollow ==··rr.NDOObjectState, "1: Reise should be hollow");
494 //················if (i.ToString()!= rr.Zweck)
495 //················{
496 //····················for (int j = 0; j < 10; j++)
497 //························System.Diagnostics.Debug.WriteLine("Reise: " + ((Reise)reisen[j]).Zweck);
498 //················}
499 #if !ORACLE && !MYSQL && !FIREBIRD
500 ················if (rr.NDOObjectId.Id[0] is Int32)
501 ····················Assert.That(i.ToString() ==··rr.Zweck, "2: Reise should be in right order");
502 #endif
503 ············}
504
505
506 ············pm.MakeAllHollow();
507 ············pm.UnloadCache();
508 ············IList reisen2 = m.Reisen;
509 ············for(int i = 0; i < 10; i++) {
510 ················Reise r1 = (Reise)reisen[i];
511 ················Reise r2 = (Reise)reisen2[i];
512 #if !ORACLE && !MYSQL && !FIREBIRD
513 ················if (r1.NDOObjectId.Id[0] is Int32)
514 ················Assert.That(i.ToString() ==··r1.Zweck, "3: Reise should be in right order");
515 #endif
516 ················Assert.That(r1 !=··r2, "Objects should be different");
517 ············}
518 ········}
519
520 ········[Test]
521 ········public void TestLoadRelatedObjectsSave() {
522 ············pm.MakePersistent(m);
523 ············pm.Save();
524 ············for(int i = 0; i < 10; i++) {
525 ················m.Hinzufuegen(CreateReise(i.ToString()));
526 ············}
527 ············pm.Save();
528 ············pm.MakeHollow(m, true);
529
530 ············IList reisen = new ArrayList(m.Reisen);
531
532 ············for(int i = 0; i < 10; i++) {
533 ················Reise rr = (Reise)reisen[i];
534 ················Assert.That(NDOObjectState.Hollow ==··rr.NDOObjectState, "1: Reise should be hollow");
535 #if !ORACLE && !MYSQL && !FIREBIRD
536 ················if (rr.NDOObjectId.Id[0] is Int32)
537 ····················Assert.That(i.ToString() ==··rr.Zweck, "2: Reise should be in right order");
538 #endif
539 ············}
540
541
542 ············pm.MakeAllHollow();
543 ············pm.UnloadCache();
544 ············IList reisen2 = m.Reisen;
545 ············for(int i = 0; i < 10; i++) {
546 ················Reise r1 = (Reise)reisen[i];
547 ················Reise r2 = (Reise)reisen2[i];
548 #if !ORACLE && !MYSQL && !FIREBIRD
549 ················if (r1.NDOObjectId.Id[0] is Int32)
550 ················Assert.That(i.ToString() ==··r1.Zweck, "3: Reise should be in right order");
551 #endif
552 ················Assert.That(r1 !=··r2, "Objects should be different");
553 ············}
554 ········}
555
556 ········[Test]
557 ········public void TestExtentRelatedObjects() {
558 ············m.Hinzufuegen(r);
559 ············pm.MakePersistent(m);
560 ············pm.Save();
561 ············IList liste = pm.GetClassExtent(typeof(Mitarbeiter));
562 ············m = (Mitarbeiter)liste[0];
563 ············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "1: Mitarbeiter should be persistent");
564 ············Assert.That(m.Reisen != null, "2. Relation is missing");
565 ············Assert.That(1 ==··m.Reisen.Count, "3. Wrong number of objects");
566 ············Assert.That(NDOObjectState.Persistent ==··((Reise)m.Reisen[0]).NDOObjectState, "4.: Reise should be hollow");
567
568 ············pm.UnloadCache();
569 ············liste = pm.GetClassExtent(typeof(Mitarbeiter));
570 ············m = (Mitarbeiter)liste[0];
571 ············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "5: Mitarbeiter should be hollow");
572 ············Assert.That(m.Reisen != null, "6. Relation is missing");
573 ············Assert.That(1 ==··m.Reisen.Count, "7. Wrong number of objects");
574 ············Assert.That(NDOObjectState.Hollow ==··((Reise)m.Reisen[0]).NDOObjectState, "8.: Reise should be hollow");
575
576 ············pm.UnloadCache();
577 ············liste = pm.GetClassExtent(typeof(Mitarbeiter), false);
578 ············m = (Mitarbeiter)liste[0];
579 ············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "9: Mitarbeiter should be persistent");
580 ············Assert.That(m.Reisen != null, "10. Relation is missing");
581 ············Assert.That(1 ==··m.Reisen.Count, "11. Wrong number of objects");
582 ············Assert.That(NDOObjectState.Hollow ==··((Reise)m.Reisen[0]).NDOObjectState, "12.: Reise should be hollow");
583 ········}
584
585 ········[Test]
586 ········public void TestReiseChangeReload()
587 ········{
588 ············m.Hinzufuegen(r);
589 ············pm.MakePersistent(m);
590 ············pm.Save();
591 ············pm.UnloadCache();
592 ············var provider = pm.NDOMapping.FindClass( typeof( Reise ) ).Provider;
593 ············NDOQuery<Reise> q = new NDOQuery<Reise>(pm, $"zweck LIKE 'A{provider.Wildcard}'");
594 ············r = (Reise) q.ExecuteSingle(true);
595 ············r.Zweck = "NewPurpose";
596 ············pm.Save();
597 ············NDOQuery<Mitarbeiter> qm = new NDOQuery<Mitarbeiter>(pm);
598 ············m = qm.ExecuteSingle(true);
599 ············Assert.That(1 ==··m.Reisen.Count, "Count wrong");
600 ············Assert.That("NewPurpose" ==··r.Zweck, "Reise wrong");
601 ········}
602
603 ········[Test]
604 ········public void RelationEmptyAssignment()
605 ········{
606 ············m.Hinzufuegen(r);
607 ············pm.MakePersistent(m);
608 ············pm.Save();
609 ············pm.UnloadCache();
610 ············m = (Mitarbeiter) pm.FindObject(m.NDOObjectId);
611 ············//Assert.That(m.Reisen.Count == 1);
612 ············m.ErsetzeReisen(new ArrayList());
613 ············pm.Save();
614 ············pm.UnloadCache();
615 //············// This code gets the same result
616 //············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>(pm, "oid = {0}");
617 //············q.Parameters.Add(m.NDOObjectId.Id.Value);
618 //············m = (Mitarbeiter) q.ExecuteSingle(true);
619
620 ············m = (Mitarbeiter) pm.FindObject(m.NDOObjectId);
621 ············Assert.That(m.Reisen.Count == 0, "Reisen should be empty");
622 ········}
623
624 ········[Test]
625 ········public void RelationNullAssignment()
626 ········{
627 ············m.Hinzufuegen(r);
628 ············pm.MakePersistent(m);
629 ············pm.Save();
630 ············pm.UnloadCache();
631 ············m = (Mitarbeiter) pm.FindObject(m.NDOObjectId);
632 ············//Assert.That(m.Reisen.Count == 1);
633 ············m.ErsetzeReisen(null);
634 ············pm.Save();
635 ············pm.UnloadCache();
636 ············m = (Mitarbeiter) pm.FindObject(m.NDOObjectId);
637 ············Assert.That(m.Reisen.Count == 0, "Reisen should be empty");
638 ········}
639
640 ········[Test]
641 ········[Ignore("persistenceHandler doesn't exist anymore")]
642 ········public void AbortedTransaction()
643 ········{
644 ············m.Hinzufuegen( r );
645 ············pm.MakePersistent( m );
646 ············pm.Save();
647 ············pm.UnloadCache();
648
649 ············pm.TransactionMode = TransactionMode.Optimistic;
650
651 ············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, null );
652 ············m = (Mitarbeiter)q.ExecuteSingle( true );
653 ············m.Vorname = "Hans";
654 ············((Reise)m.Reisen[0]).Zweck = "Neuer Zweck";
655
656 ············FieldInfo fi = pm.NDOMapping.GetType().GetField( "persistenceHandler", BindingFlags.Instance | BindingFlags.NonPublic );
657
658 ············Dictionary<Type, IPersistenceHandler> ht = (Dictionary<Type, IPersistenceHandler>)fi.GetValue( pm.NDOMapping );
659 ············ht.Clear();
660 ············pm.NDOMapping.FindClass( typeof( Reise ) ).FindField( "zweck" ).Column.Name = "nix";
661
662 ············try
663 ············{
664 ················pm.Save();
665 ············}
666 ············catch
667 ············{
668 ················ht.Clear();
669 ················pm.NDOMapping.FindClass( typeof( Reise ) ).FindField( "zweck" ).Column.Name = "Zweck";
670 ················pm.Abort();
671 ············}
672
673 ············pm.UnloadCache();
674 ············m = (Mitarbeiter)q.ExecuteSingle( true );
675 ············Assert.That("Hartmut" ==··m.Vorname, "Vorname falsch" );
676 ············Assert.That("ADC" ==··((Reise)m.Reisen[0]).Zweck, "Vorname falsch" );
677 ········}
678
679 ········[Test]
680 ········public void ResolveTest()
681 ········{
682 ············// This makes sure, that each resolve delivers a new PersistenceHandler.
683 ············var h1 = Host.Services.GetRequiredService<IPersistenceHandler>();
684 ············var h2 = Host.Services.GetRequiredService<IPersistenceHandler>();
685 ············Assert.That( !object.ReferenceEquals( h1, h2 ) );
686 ········}
687
688 ········[Test]
689 ········public void TestListEnumerator()
690 ········{
691 ············m.Hinzufuegen(r);
692 ············pm.MakePersistent(m);
693 ············pm.Save();
694 ············pm.UnloadCache();
695 ············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>(pm, null);
696 ············m = (Mitarbeiter) q.ExecuteSingle(true);
697 ············IEnumerator ie = m.Reisen.GetEnumerator();
698 ············bool result = ie.MoveNext();
699 ············Assert.That(result, "Enumerator should give a result");
700 ············Assert.That(ie.Current != null);
701 ········}
702
703 ········[Test]
704 ········public void TestListCount()
705 ········{
706 ············m.Hinzufuegen(r);
707 ············pm.MakePersistent(m);
708 ············pm.Save();
709 ············pm.UnloadCache();
710 ············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>(pm, null);
711 ············m = (Mitarbeiter) q.ExecuteSingle(true);
712 ············Assert.That(1 ==··m.Reisen.Count, "Count should be 1");
713 ········}
714
715 ········[Test]
716 ········public void TestLinqQuery()
717 ········{
718 ············m.Hinzufuegen(r);
719 ············pm.MakePersistent(m);
720 ············pm.Save();
721 ············pm.UnloadCache();
722 ············m = (from mi in pm.Objects<Mitarbeiter>() where mi.Reisen[Any.Index].Zweck == "ADC" select mi).FirstOrDefault();
723 ············Assert.That(m != null, "There should be 1 object");
724 ············Assert.That(1 ==··m.Reisen.Count, "Count should be 1");
725 ········}
726
727
728 ········private Mitarbeiter CreateMitarbeiter(string vorname, string nachname)
729 ········{
730 ············Mitarbeiter m = new Mitarbeiter();
731 ············m.Vorname = vorname;
732 ············m.Nachname = nachname;
733 ············return m;
734 ········}
735
736 ········private Reise CreateReise(string zweck) {
737 ············Reise r = new Reise();
738 ············r.Zweck = zweck;
739 ············return r;
740 ········}
741 ····}
742 }
743
New Commit (a04c7be)
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.Linq;
25 using System.Reflection;
26 using System.Collections;
27 using System.Collections.Generic;
28 using NUnit.Framework;
29 using NDO;
30 using NDO.Query;
31 using Reisekosten;
32 using Reisekosten.Personal;
33 using NDO.Linq;
34 using NDO.Mapping;
35 using Microsoft.Extensions.DependencyInjection;
36
37 namespace NdoUnitTests
38 {
39 ····/// <summary>
40 ····/// Combined Tests of Mitarbeiter and Reise to test uniqueness of object ids.
41 ····/// </summary>
42 ····[TestFixture]
43 ····public class NDOMitarbeiterReiseTests : NDOTest
44 ····{
45 ········public NDOMitarbeiterReiseTests()
46 ········{
47 ········}
48
49 ········private PersistenceManager pm;
50 ········private Mitarbeiter m;
51 ········private Reise r;
52
53 ········[SetUp]
54 ········public void Setup() {
55 ············pm = PmFactory.NewPersistenceManager();
56 ············m = CreateMitarbeiter("Hartmut", "Kocher");
57 ············r = CreateReise("ADC");
58 ········}
59
60 ········[TearDown]
61 ········public void TearDown() {
62 ············pm.Abort();
63 ············pm.UnloadCache();
64 ············var mitarbeiterListe = pm.Objects<Mitarbeiter>().ResultTable;
65 ············pm.Delete(mitarbeiterListe);
66 ············pm.Save();
67 ············pm.Objects<Reise>().DeleteDirectly();
68 ············pm.Close();
69 ············pm.Dispose();
70 ········}
71
72 ········[Test]
73 ········public void TestCreateObjects() {
74 ············pm.MakePersistent(m);
75 ············pm.MakePersistent(r);
76 ············Assert.That(!m.NDOObjectId.Equals(r.NDOObjectId), "Ids should be different");
77 ············m = (Mitarbeiter)pm.FindObject(m.NDOObjectId);
78 ············r = (Reise)pm.FindObject(r.NDOObjectId);
79 ········}
80
81 ········[Test]
82 ········public void TestCreateObjectsSave() {
83 ············m.Hinzufuegen(r);
84 ············pm.MakePersistent(m);
85 ············pm.Save();
86 ············Assert.That(!m.NDOObjectId.Equals(r.NDOObjectId), "Ids should be different");
87 ············m = (Mitarbeiter)pm.FindObject(m.NDOObjectId);
88 ············r = (Reise)pm.FindObject(r.NDOObjectId);
89 ············Assert.That(m != null, "1. Mitarbeiter not found");
90 ············Assert.That(r != null, "1. Reise not found");
91
92 ············pm.UnloadCache();
93 ············m = (Mitarbeiter)pm.FindObject(m.NDOObjectId);
94 ············r = (Reise)pm.FindObject(r.NDOObjectId);
95 ············Assert.That(m != null, "2. Mitarbeiter not found");
96 ············Assert.That(r != null, "2. Reise not found");
97 ········}
98
99 ········[Test]
100 ········public void TestAddObjectSave() {
101 ············pm.MakePersistent(m);
102 ············pm.Save();
103 ············m.Hinzufuegen(r);
104 ············Assert.That(NDOObjectState.Created ==··r.NDOObjectState, "1. Wrong state");
105 ············pm.Save();
106 ············m = (Mitarbeiter)pm.FindObject(m.NDOObjectId);
107 ············r = (Reise)pm.FindObject(r.NDOObjectId);
108 ············Assert.That(m != null, "1. Mitarbeiter not found");
109 ············Assert.That(r != null, "1. Reise not found");
110 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "2. Wrong state");
111 ········}
112
113 bool IsLoaded( IPersistentObject po, Relation r)
114 ········{
115 var pc = ( IPersistenceCapable) po;
116 var lsSupport = ( ILoadStateSupport) r;
117 return pc. NDOLoadState. RelationLoadState[lsSupport. Ordinal];
 
 
 
 
 
 
 
 
118 ········}
119
120 ········[Test]
121 ········public void RestorePreservesRelationLists()
122 ········{
123 ············pm.MakePersistent( m );
124 ············pm.Save();
125 ············m.Hinzufuegen( r );
126 ············pm.Save();
127 ············Assert.That(1 ==··m.Reisen.Count );
128
129 ············pm.UnloadCache();
130 ············var m2 = pm.Objects<Mitarbeiter>().Single();
131
132 ············var relation = pm.NDOMapping.FindClass( typeof( Mitarbeiter ) ).FindRelation( "dieReisen" );
133
134 ············Assert.That( !IsLoaded( m2, relation ) );
135 ············var list = m2.Reisen;
136 ············m2.Vorname = "Testxxxx";
137
138 ············Assert.That( IsLoaded( m2, relation ) );
139
140 ············pm.Restore( m2 );
141 ············m2.Nachname = "Testyyyy";
142 ············pm.Save();
143
144
145 ············Assert.That(1 ==··m2.Reisen.Count );
146 ········}
147
148 ········[Test]
149 ········public void TestAddObjectAbort() {
150 ············pm.MakePersistent(m);
151 ············pm.Save();
152 ············m.Hinzufuegen(r);
153 ············Assert.That(NDOObjectState.Created ==··r.NDOObjectState, "1. Wrong state");
154 ············Assert.That(1 ==··m.Reisen.Count, "1. Wrong number of objects");
155 ············pm.Abort();
156 ············Assert.That(NDOObjectState.Transient ==··r.NDOObjectState, "2. Wrong state");
157 ············Assert.That(0 ==··m.Reisen.Count, "2. Wrong number of objects");
158 ········}
159 ········[Test]
160 ········public void TestRemoveObjectSave() {
161 ············pm.MakePersistent(m);
162 ············m.Hinzufuegen(r);
163 ············pm.Save();
164 ············Assert.That(1 ==··m.Reisen.Count, "1. Wrong number of objects");
165 ············m.Löschen(r);
166 ············Assert.That(NDOObjectState.Deleted ==··r.NDOObjectState, "1. Wrong state");
167 ············Assert.That(0 ==··m.Reisen.Count, "2. Wrong number of objects");
168 ············pm.Save();
169 ············Assert.That(0 ==··m.Reisen.Count, "3. Wrong number of objects");
170 ············Assert.That(NDOObjectState.Transient ==··r.NDOObjectState, "2. Wrong state");
171 ········}
172 ············
173 ········[Test]
174 ········public void TestRemoveObjectAbort() {
175 ············pm.MakePersistent(m);
176 ············m.Hinzufuegen(r);
177 ············pm.Save();
178 ············Assert.That(1 ==··m.Reisen.Count, "1. Wrong number of objects");
179 ············m.Löschen(r);
180 ············Assert.That(NDOObjectState.Deleted ==··r.NDOObjectState, "1. Wrong state");
181 ············Assert.That(0 ==··m.Reisen.Count, "2. Wrong number of objects");
182 ············pm.Abort();
183 ············Assert.That(1 ==··m.Reisen.Count, "3. Wrong number of objects");
184 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "2. Wrong state");
185 ········}
186
187 ········[Test]
188 ········public void TestDeleteSave() {
189 ············pm.MakePersistent(m);
190 ············m.Hinzufuegen(r);
191 ············pm.Save();
192 ············pm.Delete(m);
193 ············Assert.That(NDOObjectState.Deleted ==··m.NDOObjectState, "1. Wrong state");
194 ············Assert.That(NDOObjectState.Deleted ==··r.NDOObjectState, "2. Wrong state");
195 ············pm.Save();
196 ············Assert.That(NDOObjectState.Transient ==··m.NDOObjectState, "1. Wrong state");
197 ············Assert.That(NDOObjectState.Transient ==··r.NDOObjectState, "2. Wrong state");
198 ········}
199
200
201
202 ········[Test]
203 ········public void TestDeleteAbort() {
204 ············pm.MakePersistent(m);
205 ············m.Hinzufuegen(r);
206 ············pm.Save();
207 ············pm.Delete(m);
208 ············Assert.That(NDOObjectState.Deleted ==··m.NDOObjectState, "1. Wrong state");
209 ············Assert.That(NDOObjectState.Deleted ==··r.NDOObjectState, "2. Wrong state");
210 ············pm.Abort();
211 ············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "1. Wrong state");
212 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "2. Wrong state");
213 ········}
214
215 ········[Test]
216 ········public void TestAddRemoveSave() {
217 ············pm.MakePersistent(m);
218 ············pm.Save();
219 ············m.Hinzufuegen(r);
220 ············m.Löschen(r);
221 ············Assert.That(NDOObjectState.Transient ==··r.NDOObjectState, "1. Wrong state");
222 ············pm.Save();
223 ············Assert.That(NDOObjectState.Transient ==··r.NDOObjectState, "2. Wrong state");
224 ········}
225
226 ········[Test]
227 ········public void TestAddRemoveAbort() {
228 ············pm.MakePersistent(m);
229 ············pm.Save();
230 ············m.Hinzufuegen(r);
231 ············m.Löschen(r);
232 ············Assert.That(NDOObjectState.Transient ==··r.NDOObjectState, "1. Wrong state");
233 ············pm.Abort();
234 ············Assert.That(NDOObjectState.Transient ==··r.NDOObjectState, "2. Wrong state");
235 ········}
236
237 ········[Test]
238 ········public void TestClearRelatedObjectsSave() {
239 ············for(int i = 0; i < 10; i++) {
240 ················m.Hinzufuegen(CreateReise(i.ToString()));
241 ············}
242 ············pm.MakePersistent(m);
243 ············pm.Save();
244 ············IList rr = new ArrayList(m.Reisen);
245 ············m.LöscheReisen();
246 ············Assert.That(0 ==··m.Reisen.Count, "1. Wrong number of objects");
247 ············for(int i = 0; i < 10; i++) {
248 ················Assert.That(NDOObjectState.Deleted ==··((Reise)rr[i]).NDOObjectState, "2. Wrong state");
249 ············}
250 ············pm.Save();
251 ············Assert.That(0 ==··m.Reisen.Count, "3. Wrong number of objects");
252 ············for(int i = 0; i < 10; i++) {
253 ················Assert.That(NDOObjectState.Transient ==··((Reise)rr[i]).NDOObjectState, "4. Wrong state");
254 ············}
255 ········}
256
257 ········[Test]
258 ········public void TestClearRelatedObjectsAbort() {
259 ············for(int i = 0; i < 10; i++) {
260 ················m.Hinzufuegen(CreateReise(i.ToString()));
261 ············}
262 ············pm.MakePersistent(m);
263 ············pm.Save();
264 ············IList rr = new ArrayList(m.Reisen);
265 ············m.LöscheReisen();
266 ············Assert.That(0 ==··m.Reisen.Count, "1. Wrong number of objects");
267 ············for(int i = 0; i < 10; i++) {
268 ················Assert.That(NDOObjectState.Deleted ==··((Reise)rr[i]).NDOObjectState, "2. Wrong state");
269 ············}
270 ············pm.Abort();
271 ············Assert.That(10 ==··m.Reisen.Count, "3. Wrong number of objects");
272 ············for(int i = 0; i < 10; i++) {
273 ················Assert.That(NDOObjectState.Persistent ==··((Reise)rr[i]).NDOObjectState, "4. Wrong state");
274 ············}
275 ········}
276
277 ········[Test]
278 ········public void TestAssignRelatedObjectsNullSave() {
279 ············for(int i = 0; i < 3; i++) {
280 ················m.Hinzufuegen(CreateReise(i.ToString()));
281 ············}
282 ············pm.MakePersistent(m);
283 ············pm.Save();
284 ············IList rr = new ArrayList(m.Reisen);
285 ············m.ErsetzeReisen(null);
286 ············Assert.That(m.Reisen == null, "No objects should be there");
287 ············for(int i = 0; i < 3; i++) {
288 ················Assert.That(NDOObjectState.Deleted ==··((Reise)rr[i]).NDOObjectState, "2. Wrong state");
289 ············}
290 ············pm.Save();
291 ············Assert.That(m.Reisen == null, "No objects should be there");
292 ············for(int i = 0; i < 3; i++) {
293 ················Assert.That(NDOObjectState.Transient ==··((Reise)rr[i]).NDOObjectState, "4. Wrong state");
294 ············}
295 ········}
296
297 ········[Test]
298 ········public void TestAssignRelatedObjectsNullAbort() {
299 ············for(int i = 0; i < 3; i++) {
300 ················m.Hinzufuegen(CreateReise(i.ToString()));
301 ············}
302 ············pm.MakePersistent(m);
303 ············pm.Save();
304 ············IList rr = new ArrayList(m.Reisen);
305 ············m.ErsetzeReisen(null);
306 ············Assert.That(m.Reisen == null, "No objects should be there");
307 ············for(int i = 0; i < 3; i++) {
308 ················Assert.That(NDOObjectState.Deleted ==··((Reise)rr[i]).NDOObjectState, "2. Wrong state");
309 ············}
310 ············pm.Abort();
311 ············Assert.That(3 ==··m.Reisen.Count, "3. Wrong number of objects");
312 ············for(int i = 0; i < 3; i++) {
313 ················Assert.That(NDOObjectState.Persistent ==··((Reise)rr[i]).NDOObjectState, "4. Wrong state");
314 ············}
315 ········}
316
317 ········[Test]
318 ········public void TestAssignRelatedObjectsSave() {
319 ············for(int i = 0; i < 3; i++) {
320 ················m.Hinzufuegen(CreateReise(i.ToString()));
321 ············}
322 ············pm.MakePersistent(m);
323 ············pm.Save();
324 ············IList neueReisen = new ArrayList();
325 ············Reise nr = CreateReise("Test");
326 ············neueReisen.Add(nr);
327
328 ············IList rr = new ArrayList(m.Reisen);
329 ············m.ErsetzeReisen(neueReisen);
330 ············Assert.That(1 ==··m.Reisen.Count, "1. Wrong number of objects");
331 ············for(int i = 0; i < 3; i++) {
332 ················Assert.That(NDOObjectState.Deleted ==··((Reise)rr[i]).NDOObjectState, "2. Wrong state");
333 ············}
334 ············Assert.That(NDOObjectState.Created ==··nr.NDOObjectState, "3. Wrong state");
335
336 ············pm.Save();
337 ············Assert.That(1 ==··m.Reisen.Count, "4. Wrong number of objects");
338 ············for(int i = 0; i < 3; i++) {
339 ················Assert.That(NDOObjectState.Transient ==··((Reise)rr[i]).NDOObjectState, "5. Wrong state");
340 ············}
341 ············Assert.That(NDOObjectState.Persistent ==··nr.NDOObjectState, "6. Wrong state");
342 ········}
343
344 ········[Test]
345 ········public void TestAssignRelatedObjectsAbort() {
346 ············for(int i = 0; i < 3; i++) {
347 ················m.Hinzufuegen(CreateReise(i.ToString()));
348 ············}
349 ············pm.MakePersistent(m);
350 ············pm.Save();
351 ············IList neueReisen = new ArrayList();
352 ············Reise nr = CreateReise("Test");
353 ············neueReisen.Add(nr);
354
355 ············IList rr = new ArrayList(m.Reisen);
356 ············m.ErsetzeReisen(neueReisen);
357 ············Assert.That(1 ==··m.Reisen.Count, "1. Wrong number of objects");
358 ············for(int i = 0; i < 3; i++) {
359 ················Assert.That(NDOObjectState.Deleted ==··((Reise)rr[i]).NDOObjectState, "2. Wrong state");
360 ············}
361 ············Assert.That(NDOObjectState.Created ==··nr.NDOObjectState, "3. Wrong state");
362
363 ············pm.Abort();
364 ············Assert.That(3 ==··m.Reisen.Count, "4. Wrong number of objects");
365 ············for(int i = 0; i < 3; i++) {
366 ················Assert.That(NDOObjectState.Persistent ==··((Reise)rr[i]).NDOObjectState, "5. Wrong state");
367 ············}
368 ············Assert.That(NDOObjectState.Transient ==··nr.NDOObjectState, "6. Wrong state");
369 ········}
370
371 ········[Test]
372 ········public void TestAddNewReise()
373 ········{
374 ············m.Hinzufuegen(r);
375 ············pm.MakePersistent(m);
376 ············pm.Save();
377 ············pm.UnloadCache();
378 ············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>(pm);
379 ············m = q.ExecuteSingle(true);
380 ············Reise r2 = CreateReise("Schnulli");
381 ············m.Hinzufuegen(r2);
382 ············pm.Save();
383 ············m = q.ExecuteSingle(true);
384 ············Assert.That(2 ==··m.Reisen.Count, "Count wrong");
385 ········}
386
387 ········[Test]
388 ········public void RefreshReloadsRelation()
389 ········{
390 ············m.Hinzufuegen( r );
391 ············pm.MakePersistent( m );
392 ············pm.Save();
393 ············PersistenceManager pm2 = PmFactory.NewPersistenceManager();
394 ············Mitarbeiter m2 = pm2.Objects<Mitarbeiter>().ResultTable.First();
395 ············Assert.That(m.Reisen.Count ==··m2.Reisen.Count );
396 ············Assert.That(1 ==··m.Reisen.Count );
397 ············Reise r2 = new Reise() { Zweck = "Test" };
398 ············m2.Hinzufuegen( r2 );
399 ············pm2.Save();
400 ············Assert.That(1 ==··m.Reisen.Count );
401 ············pm.Refresh( m );
402 ············Assert.That(2 ==··m.Reisen.Count );
403 ········}
404
405 ········[Test]
406 ········public void CanIterateThrougRelatedObjectsWithLinq()
407 ········{
408 ············m.Hinzufuegen( r );
409 ············r = new Reise() { Zweck = "Test" };
410 ············m.Hinzufuegen( r );
411 ············pm.MakePersistent( m );
412 ············pm.Save();
413 ············Assert.That(2 ==··m.Reisen.Count );
414 ············ObjectId oid = m.NDOObjectId;
415 ············pm.UnloadCache();
416 ············pm = PmFactory.NewPersistenceManager();
417 ············m = (Mitarbeiter) pm.FindObject( oid );
418 ············Assert.That( m.NDOObjectState == NDOObjectState.Hollow );
419 ············Reise tr = (from reise in m.Reisen where reise.Zweck == "Test" select reise).SingleOrDefault();
420 ············Assert.That(tr··!= null);
421 ············Assert.That("Test" ==··tr.Zweck );
422 ········}
423
424 ········[Test]
425 ········public void TestHollow() {
426 ············m.Hinzufuegen(r);
427 ············pm.MakePersistent(m);
428 ············pm.Save();
429 ············pm.MakeHollow(m);
430 ············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "1: Mitarbeiter should be hollow");
431 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "1: Reise should be persistent");
432 ············IList reise = m.Reisen;
433
434 ············pm.MakeHollow(m, true);
435 ············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "2: Mitarbeiter should be hollow");
436 ············Assert.That(NDOObjectState.Hollow ==··r.NDOObjectState, "2: Reise should be hollow");
437
438 ············reise = m.Reisen;
439 ············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "3: Mitarbeiter should be persistent");
440 ············Assert.That(NDOObjectState.Hollow ==··r.NDOObjectState, "3: Reise should be hollow");
441 ············Assert.That("ADC" ==··r.Zweck, "3: Reise should have correct Zweck");
442 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "4: Reise should be persistent");
443 ········}
444
445 ········[Test]
446 ········public void··TestMakeAllHollow() {
447 ············m.Hinzufuegen(r);
448 ············pm.MakePersistent(m);
449 ············pm.Save();
450 ············pm.MakeAllHollow();
451 ············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "1: Mitarbeiter should be hollow");
452 ············Assert.That(NDOObjectState.Hollow ==··r.NDOObjectState, "1: Reise should be hollow");
453 ············pm.UnloadCache();
454 ········}
455
456 ········[Test]
457 ········public void··TestMakeAllHollowUnsaved() {
458 ············m.Hinzufuegen(r);
459 ············pm.MakePersistent(m);
460 ············pm.MakeAllHollow();··// before save, objects cannot be made hollow. => in locked objects
461 ············Assert.That(NDOObjectState.Created ==··m.NDOObjectState, "1: Mitarbeiter should be created");
462 ············Assert.That(NDOObjectState.Created ==··r.NDOObjectState, "1: Reise should be created");
463 ········}
464
465 ········[Test]
466 ········public void TestLoadRelatedObjects() {
467 ············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>(pm, null);
468 ············IList dellist = q.Execute();
469 ············pm.Delete(dellist);
470 ············pm.Save();
471 ············pm.UnloadCache();
472
473 ············for(int i = 0; i < 10; i++) {
474 ················m.Hinzufuegen(CreateReise(i.ToString()));
475 ············}
476 ············pm.MakePersistent(m);
477 ············pm.Save();
478 ············pm.MakeHollow(m, true);
479
480 ············IList reisen = new ArrayList(m.Reisen);
481 ············Assert.That(10 ==··reisen.Count, "Array size should be 10");
482
483 ············for(int i = 0; i < 10; i++) {
484 ················Reise rr = (Reise)reisen[i];
485 ················Assert.That(NDOObjectState.Hollow ==··rr.NDOObjectState, "1: Reise should be hollow");
486 //················if (i.ToString()!= rr.Zweck)
487 //················{
488 //····················for (int j = 0; j < 10; j++)
489 //························System.Diagnostics.Debug.WriteLine("Reise: " + ((Reise)reisen[j]).Zweck);
490 //················}
491 #if !ORACLE && !MYSQL && !FIREBIRD
492 ················if (rr.NDOObjectId.Id[0] is Int32)
493 ····················Assert.That(i.ToString() ==··rr.Zweck, "2: Reise should be in right order");
494 #endif
495 ············}
496
497
498 ············pm.MakeAllHollow();
499 ············pm.UnloadCache();
500 ············IList reisen2 = m.Reisen;
501 ············for(int i = 0; i < 10; i++) {
502 ················Reise r1 = (Reise)reisen[i];
503 ················Reise r2 = (Reise)reisen2[i];
504 #if !ORACLE && !MYSQL && !FIREBIRD
505 ················if (r1.NDOObjectId.Id[0] is Int32)
506 ················Assert.That(i.ToString() ==··r1.Zweck, "3: Reise should be in right order");
507 #endif
508 ················Assert.That(r1 !=··r2, "Objects should be different");
509 ············}
510 ········}
511
512 ········[Test]
513 ········public void TestLoadRelatedObjectsSave() {
514 ············pm.MakePersistent(m);
515 ············pm.Save();
516 ············for(int i = 0; i < 10; i++) {
517 ················m.Hinzufuegen(CreateReise(i.ToString()));
518 ············}
519 ············pm.Save();
520 ············pm.MakeHollow(m, true);
521
522 ············IList reisen = new ArrayList(m.Reisen);
523
524 ············for(int i = 0; i < 10; i++) {
525 ················Reise rr = (Reise)reisen[i];
526 ················Assert.That(NDOObjectState.Hollow ==··rr.NDOObjectState, "1: Reise should be hollow");
527 #if !ORACLE && !MYSQL && !FIREBIRD
528 ················if (rr.NDOObjectId.Id[0] is Int32)
529 ····················Assert.That(i.ToString() ==··rr.Zweck, "2: Reise should be in right order");
530 #endif
531 ············}
532
533
534 ············pm.MakeAllHollow();
535 ············pm.UnloadCache();
536 ············IList reisen2 = m.Reisen;
537 ············for(int i = 0; i < 10; i++) {
538 ················Reise r1 = (Reise)reisen[i];
539 ················Reise r2 = (Reise)reisen2[i];
540 #if !ORACLE && !MYSQL && !FIREBIRD
541 ················if (r1.NDOObjectId.Id[0] is Int32)
542 ················Assert.That(i.ToString() ==··r1.Zweck, "3: Reise should be in right order");
543 #endif
544 ················Assert.That(r1 !=··r2, "Objects should be different");
545 ············}
546 ········}
547
548 ········[Test]
549 ········public void TestExtentRelatedObjects() {
550 ············m.Hinzufuegen(r);
551 ············pm.MakePersistent(m);
552 ············pm.Save();
553 ············IList liste = pm.GetClassExtent(typeof(Mitarbeiter));
554 ············m = (Mitarbeiter)liste[0];
555 ············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "1: Mitarbeiter should be persistent");
556 ············Assert.That(m.Reisen != null, "2. Relation is missing");
557 ············Assert.That(1 ==··m.Reisen.Count, "3. Wrong number of objects");
558 ············Assert.That(NDOObjectState.Persistent ==··((Reise)m.Reisen[0]).NDOObjectState, "4.: Reise should be hollow");
559
560 ············pm.UnloadCache();
561 ············liste = pm.GetClassExtent(typeof(Mitarbeiter));
562 ············m = (Mitarbeiter)liste[0];
563 ············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "5: Mitarbeiter should be hollow");
564 ············Assert.That(m.Reisen != null, "6. Relation is missing");
565 ············Assert.That(1 ==··m.Reisen.Count, "7. Wrong number of objects");
566 ············Assert.That(NDOObjectState.Hollow ==··((Reise)m.Reisen[0]).NDOObjectState, "8.: Reise should be hollow");
567
568 ············pm.UnloadCache();
569 ············liste = pm.GetClassExtent(typeof(Mitarbeiter), false);
570 ············m = (Mitarbeiter)liste[0];
571 ············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "9: Mitarbeiter should be persistent");
572 ············Assert.That(m.Reisen != null, "10. Relation is missing");
573 ············Assert.That(1 ==··m.Reisen.Count, "11. Wrong number of objects");
574 ············Assert.That(NDOObjectState.Hollow ==··((Reise)m.Reisen[0]).NDOObjectState, "12.: Reise should be hollow");
575 ········}
576
577 ········[Test]
578 ········public void TestReiseChangeReload()
579 ········{
580 ············m.Hinzufuegen(r);
581 ············pm.MakePersistent(m);
582 ············pm.Save();
583 ············pm.UnloadCache();
584 ············var provider = pm.NDOMapping.FindClass( typeof( Reise ) ).Provider;
585 ············NDOQuery<Reise> q = new NDOQuery<Reise>(pm, $"zweck LIKE 'A{provider.Wildcard}'");
586 ············r = (Reise) q.ExecuteSingle(true);
587 ············r.Zweck = "NewPurpose";
588 ············pm.Save();
589 ············NDOQuery<Mitarbeiter> qm = new NDOQuery<Mitarbeiter>(pm);
590 ············m = qm.ExecuteSingle(true);
591 ············Assert.That(1 ==··m.Reisen.Count, "Count wrong");
592 ············Assert.That("NewPurpose" ==··r.Zweck, "Reise wrong");
593 ········}
594
595 ········[Test]
596 ········public void RelationEmptyAssignment()
597 ········{
598 ············m.Hinzufuegen(r);
599 ············pm.MakePersistent(m);
600 ············pm.Save();
601 ············pm.UnloadCache();
602 ············m = (Mitarbeiter) pm.FindObject(m.NDOObjectId);
603 ············//Assert.That(m.Reisen.Count == 1);
604 ············m.ErsetzeReisen(new ArrayList());
605 ············pm.Save();
606 ············pm.UnloadCache();
607 //············// This code gets the same result
608 //············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>(pm, "oid = {0}");
609 //············q.Parameters.Add(m.NDOObjectId.Id.Value);
610 //············m = (Mitarbeiter) q.ExecuteSingle(true);
611
612 ············m = (Mitarbeiter) pm.FindObject(m.NDOObjectId);
613 ············Assert.That(m.Reisen.Count == 0, "Reisen should be empty");
614 ········}
615
616 ········[Test]
617 ········public void RelationNullAssignment()
618 ········{
619 ············m.Hinzufuegen(r);
620 ············pm.MakePersistent(m);
621 ············pm.Save();
622 ············pm.UnloadCache();
623 ············m = (Mitarbeiter) pm.FindObject(m.NDOObjectId);
624 ············//Assert.That(m.Reisen.Count == 1);
625 ············m.ErsetzeReisen(null);
626 ············pm.Save();
627 ············pm.UnloadCache();
628 ············m = (Mitarbeiter) pm.FindObject(m.NDOObjectId);
629 ············Assert.That(m.Reisen.Count == 0, "Reisen should be empty");
630 ········}
631
632 ········[Test]
633 ········[Ignore("persistenceHandler doesn't exist anymore")]
634 ········public void AbortedTransaction()
635 ········{
636 ············m.Hinzufuegen( r );
637 ············pm.MakePersistent( m );
638 ············pm.Save();
639 ············pm.UnloadCache();
640
641 ············pm.TransactionMode = TransactionMode.Optimistic;
642
643 ············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, null );
644 ············m = (Mitarbeiter)q.ExecuteSingle( true );
645 ············m.Vorname = "Hans";
646 ············((Reise)m.Reisen[0]).Zweck = "Neuer Zweck";
647
648 ············FieldInfo fi = pm.NDOMapping.GetType().GetField( "persistenceHandler", BindingFlags.Instance | BindingFlags.NonPublic );
649
650 ············Dictionary<Type, IPersistenceHandler> ht = (Dictionary<Type, IPersistenceHandler>)fi.GetValue( pm.NDOMapping );
651 ············ht.Clear();
652 ············pm.NDOMapping.FindClass( typeof( Reise ) ).FindField( "zweck" ).Column.Name = "nix";
653
654 ············try
655 ············{
656 ················pm.Save();
657 ············}
658 ············catch
659 ············{
660 ················ht.Clear();
661 ················pm.NDOMapping.FindClass( typeof( Reise ) ).FindField( "zweck" ).Column.Name = "Zweck";
662 ················pm.Abort();
663 ············}
664
665 ············pm.UnloadCache();
666 ············m = (Mitarbeiter)q.ExecuteSingle( true );
667 ············Assert.That("Hartmut" ==··m.Vorname, "Vorname falsch" );
668 ············Assert.That("ADC" ==··((Reise)m.Reisen[0]).Zweck, "Vorname falsch" );
669 ········}
670
671 ········[Test]
672 ········public void ResolveTest()
673 ········{
674 ············// This makes sure, that each resolve delivers a new PersistenceHandler.
675 ············var h1 = Host.Services.GetRequiredService<IPersistenceHandler>();
676 ············var h2 = Host.Services.GetRequiredService<IPersistenceHandler>();
677 ············Assert.That( !object.ReferenceEquals( h1, h2 ) );
678 ········}
679
680 ········[Test]
681 ········public void TestListEnumerator()
682 ········{
683 ············m.Hinzufuegen(r);
684 ············pm.MakePersistent(m);
685 ············pm.Save();
686 ············pm.UnloadCache();
687 ············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>(pm, null);
688 ············m = (Mitarbeiter) q.ExecuteSingle(true);
689 ············IEnumerator ie = m.Reisen.GetEnumerator();
690 ············bool result = ie.MoveNext();
691 ············Assert.That(result, "Enumerator should give a result");
692 ············Assert.That(ie.Current != null);
693 ········}
694
695 ········[Test]
696 ········public void TestListCount()
697 ········{
698 ············m.Hinzufuegen(r);
699 ············pm.MakePersistent(m);
700 ············pm.Save();
701 ············pm.UnloadCache();
702 ············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>(pm, null);
703 ············m = (Mitarbeiter) q.ExecuteSingle(true);
704 ············Assert.That(1 ==··m.Reisen.Count, "Count should be 1");
705 ········}
706
707 ········[Test]
708 ········public void TestLinqQuery()
709 ········{
710 ············m.Hinzufuegen(r);
711 ············pm.MakePersistent(m);
712 ············pm.Save();
713 ············pm.UnloadCache();
714 ············m = (from mi in pm.Objects<Mitarbeiter>() where mi.Reisen[Any.Index].Zweck == "ADC" select mi).FirstOrDefault();
715 ············Assert.That(m != null, "There should be 1 object");
716 ············Assert.That(1 ==··m.Reisen.Count, "Count should be 1");
717 ········}
718
719
720 ········private Mitarbeiter CreateMitarbeiter(string vorname, string nachname)
721 ········{
722 ············Mitarbeiter m = new Mitarbeiter();
723 ············m.Vorname = vorname;
724 ············m.Nachname = nachname;
725 ············return m;
726 ········}
727
728 ········private Reise CreateReise(string zweck) {
729 ············Reise r = new Reise();
730 ············r.Zweck = zweck;
731 ············return r;
732 ········}
733 ····}
734 }
735