Datei: IntegrationTests/NdoUnitTests/NDOMitarbeiterReiseTests.cs

Last Commit (f90cc9c)
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
36 namespace NdoUnitTests
37 {
38 ····/// <summary>
39 ····/// Combined Tests of Mitarbeiter and Reise to test uniqueness of object ids.
40 ····/// </summary>
41 ····[TestFixture]
42 ····public class NDOMitarbeiterReiseTests
43 ····{
44 ········public NDOMitarbeiterReiseTests()
45 ········{
46 ········}
47
48 ········private PersistenceManager pm;
49 ········private Mitarbeiter m;
50 ········private Reise r;
51
52 ········[SetUp]
53 ········public void Setup() {
54 ············pm = PmFactory.NewPersistenceManager();
55 ············m = CreateMitarbeiter("Hartmut", "Kocher");
56 ············r = CreateReise("ADC");
57 ········}
58
59 ········[TearDown]
60 ········public void TearDown() {
61 ············pm.Abort();
62 ············pm.UnloadCache();
63 ············IList mitarbeiterListe = pm.GetClassExtent(typeof(Mitarbeiter), true);
64 ············pm.Delete(mitarbeiterListe);
65 ············pm.Save();
66 ············pm.Close();
67 ············pm.GetSqlPassThroughHandler().Execute( "DELETE FROM " + pm.NDOMapping.FindClass( typeof( Reise ) ).TableName );
68 ············pm.Dispose();
69 ········}
70
71 ········[Test]
72 ········public void TestCreateObjects() {
73 ············pm.MakePersistent(m);
74 ············pm.MakePersistent(r);
75 ············Assert.That(!m.NDOObjectId.Equals(r.NDOObjectId), "Ids should be different");
76 ············m = (Mitarbeiter)pm.FindObject(m.NDOObjectId);
77 ············r = (Reise)pm.FindObject(r.NDOObjectId);
78 ········}
79
80 ········[Test]
81 ········public void TestCreateObjectsSave() {
82 ············m.Hinzufuegen(r);
83 ············pm.MakePersistent(m);
84 ············pm.Save();
85 ············Assert.That(!m.NDOObjectId.Equals(r.NDOObjectId), "Ids should be different");
86 ············m = (Mitarbeiter)pm.FindObject(m.NDOObjectId);
87 ············r = (Reise)pm.FindObject(r.NDOObjectId);
88 ············Assert.NotNull(m, "1. Mitarbeiter not found");
89 ············Assert.NotNull(r, "1. Reise not found");
90
91 ············pm.UnloadCache();
92 ············m = (Mitarbeiter)pm.FindObject(m.NDOObjectId);
93 ············r = (Reise)pm.FindObject(r.NDOObjectId);
94 ············Assert.NotNull(m, "2. Mitarbeiter not found");
95 ············Assert.NotNull(r, "2. Reise not found");
96 ········}
97
98 ········[Test]
99 ········public void TestAddObjectSave() {
100 ············pm.MakePersistent(m);
101 ············pm.Save();
102 ············m.Hinzufuegen(r);
103 ············Assert.AreEqual(NDOObjectState.Created, r.NDOObjectState, "1. Wrong state");
104 ············pm.Save();
105 ············m = (Mitarbeiter)pm.FindObject(m.NDOObjectId);
106 ············r = (Reise)pm.FindObject(r.NDOObjectId);
107 ············Assert.NotNull(m, "1. Mitarbeiter not found");
108 ············Assert.NotNull(r, "1. Reise not found");
109 ············Assert.AreEqual(NDOObjectState.Persistent, r.NDOObjectState, "2. Wrong state");
110 ········}
111
112 ········int GetOrdinal(Relation r)
113 ········{
114 ············var t = r.Parent.SystemType;
115 ············Type mcType = t.GetNestedType( "MetaClass", BindingFlags.NonPublic | BindingFlags.Public );
116 ············if (null == mcType)
117 ················throw new NDOException( 13, "Missing nested class 'MetaClass' for type '" + t.Name + "'; the type doesn't seem to be enhanced." );
118 var mc = ( IMetaClass) Activator. CreateInstance( mcType ) ;
119 ············return mc.GetRelationOrdinal( r.FieldName );
120 ········}
121
122 ········bool IsLoaded(IPersistentObject pc, Relation r)
123 ········{
124 ············return ((IPersistenceCapable)pc).NDOLoadState.RelationLoadState[GetOrdinal( r )];
125 ········}
126
127 ········[Test]
128 ········public void RestorePreservesRelationLists()
129 ········{
130 ············pm.MakePersistent( m );
131 ············pm.Save();
132 ············m.Hinzufuegen( r );
133 ············pm.Save();
134 ············Assert.AreEqual( 1, m.Reisen.Count );
135
136 ············pm.UnloadCache();
137 ············var m2 = pm.Objects<Mitarbeiter>().Single();
138
139 ············var relation = pm.NDOMapping.FindClass( typeof( Mitarbeiter ) ).FindRelation( "dieReisen" );
140
141 ············Assert.That( !IsLoaded( m2, relation ) );
142 ············var list = m2.Reisen;
143 ············m2.Vorname = "Testxxxx";
144
145 ············Assert.That( IsLoaded( m2, relation ) );
146
147 ············pm.Restore( m2 );
148 ············m2.Nachname = "Testyyyy";
149 ············pm.Save();
150
151 ············Assert.AreEqual( 1, m2.Reisen.Count );
152 ········}
153
154 ········[Test]
155 ········public void TestAddObjectAbort() {
156 ············pm.MakePersistent(m);
157 ············pm.Save();
158 ············m.Hinzufuegen(r);
159 ············Assert.AreEqual(NDOObjectState.Created, r.NDOObjectState, "1. Wrong state");
160 ············Assert.AreEqual(1, m.Reisen.Count, "1. Wrong number of objects");
161 ············pm.Abort();
162 ············Assert.AreEqual(NDOObjectState.Transient, r.NDOObjectState, "2. Wrong state");
163 ············Assert.AreEqual(0, m.Reisen.Count, "2. Wrong number of objects");
164 ········}
165 ········[Test]
166 ········public void TestRemoveObjectSave() {
167 ············pm.MakePersistent(m);
168 ············m.Hinzufuegen(r);
169 ············pm.Save();
170 ············Assert.AreEqual(1, m.Reisen.Count, "1. Wrong number of objects");
171 ············m.Löschen(r);
172 ············Assert.AreEqual(NDOObjectState.Deleted, r.NDOObjectState, "1. Wrong state");
173 ············Assert.AreEqual(0, m.Reisen.Count, "2. Wrong number of objects");
174 ············pm.Save();
175 ············Assert.AreEqual(0, m.Reisen.Count, "3. Wrong number of objects");
176 ············Assert.AreEqual(NDOObjectState.Transient, r.NDOObjectState, "2. Wrong state");
177 ········}
178 ············
179 ········[Test]
180 ········public void TestRemoveObjectAbort() {
181 ············pm.MakePersistent(m);
182 ············m.Hinzufuegen(r);
183 ············pm.Save();
184 ············Assert.AreEqual(1, m.Reisen.Count, "1. Wrong number of objects");
185 ············m.Löschen(r);
186 ············Assert.AreEqual(NDOObjectState.Deleted, r.NDOObjectState, "1. Wrong state");
187 ············Assert.AreEqual(0, m.Reisen.Count, "2. Wrong number of objects");
188 ············pm.Abort();
189 ············Assert.AreEqual(1, m.Reisen.Count, "3. Wrong number of objects");
190 ············Assert.AreEqual(NDOObjectState.Persistent, r.NDOObjectState, "2. Wrong state");
191 ········}
192
193 ········[Test]
194 ········public void TestDeleteSave() {
195 ············pm.MakePersistent(m);
196 ············m.Hinzufuegen(r);
197 ············pm.Save();
198 ············pm.Delete(m);
199 ············Assert.AreEqual(NDOObjectState.Deleted, m.NDOObjectState, "1. Wrong state");
200 ············Assert.AreEqual(NDOObjectState.Deleted, r.NDOObjectState, "2. Wrong state");
201 ············pm.Save();
202 ············Assert.AreEqual(NDOObjectState.Transient, m.NDOObjectState, "1. Wrong state");
203 ············Assert.AreEqual(NDOObjectState.Transient, r.NDOObjectState, "2. Wrong state");
204 ········}
205
206
207
208 ········[Test]
209 ········public void TestDeleteAbort() {
210 ············pm.MakePersistent(m);
211 ············m.Hinzufuegen(r);
212 ············pm.Save();
213 ············pm.Delete(m);
214 ············Assert.AreEqual(NDOObjectState.Deleted, m.NDOObjectState, "1. Wrong state");
215 ············Assert.AreEqual(NDOObjectState.Deleted, r.NDOObjectState, "2. Wrong state");
216 ············pm.Abort();
217 ············Assert.AreEqual(NDOObjectState.Persistent, m.NDOObjectState, "1. Wrong state");
218 ············Assert.AreEqual(NDOObjectState.Persistent, r.NDOObjectState, "2. Wrong state");
219 ········}
220
221 ········[Test]
222 ········public void TestAddRemoveSave() {
223 ············pm.MakePersistent(m);
224 ············pm.Save();
225 ············m.Hinzufuegen(r);
226 ············m.Löschen(r);
227 ············Assert.AreEqual(NDOObjectState.Transient, r.NDOObjectState, "1. Wrong state");
228 ············pm.Save();
229 ············Assert.AreEqual(NDOObjectState.Transient, r.NDOObjectState, "2. Wrong state");
230 ········}
231
232 ········[Test]
233 ········public void TestAddRemoveAbort() {
234 ············pm.MakePersistent(m);
235 ············pm.Save();
236 ············m.Hinzufuegen(r);
237 ············m.Löschen(r);
238 ············Assert.AreEqual(NDOObjectState.Transient, r.NDOObjectState, "1. Wrong state");
239 ············pm.Abort();
240 ············Assert.AreEqual(NDOObjectState.Transient, r.NDOObjectState, "2. Wrong state");
241 ········}
242
243 ········[Test]
244 ········public void TestClearRelatedObjectsSave() {
245 ············for(int i = 0; i < 10; i++) {
246 ················m.Hinzufuegen(CreateReise(i.ToString()));
247 ············}
248 ············pm.MakePersistent(m);
249 ············pm.Save();
250 ············IList rr = new ArrayList(m.Reisen);
251 ············m.LöscheReisen();
252 ············Assert.AreEqual(0, m.Reisen.Count, "1. Wrong number of objects");
253 ············for(int i = 0; i < 10; i++) {
254 ················Assert.AreEqual(NDOObjectState.Deleted, ((Reise)rr[i]).NDOObjectState, "2. Wrong state");
255 ············}
256 ············pm.Save();
257 ············Assert.AreEqual(0, m.Reisen.Count, "3. Wrong number of objects");
258 ············for(int i = 0; i < 10; i++) {
259 ················Assert.AreEqual(NDOObjectState.Transient, ((Reise)rr[i]).NDOObjectState, "4. Wrong state");
260 ············}
261 ········}
262
263 ········[Test]
264 ········public void TestClearRelatedObjectsAbort() {
265 ············for(int i = 0; i < 10; i++) {
266 ················m.Hinzufuegen(CreateReise(i.ToString()));
267 ············}
268 ············pm.MakePersistent(m);
269 ············pm.Save();
270 ············IList rr = new ArrayList(m.Reisen);
271 ············m.LöscheReisen();
272 ············Assert.AreEqual(0, m.Reisen.Count, "1. Wrong number of objects");
273 ············for(int i = 0; i < 10; i++) {
274 ················Assert.AreEqual(NDOObjectState.Deleted, ((Reise)rr[i]).NDOObjectState, "2. Wrong state");
275 ············}
276 ············pm.Abort();
277 ············Assert.AreEqual(10, m.Reisen.Count, "3. Wrong number of objects");
278 ············for(int i = 0; i < 10; i++) {
279 ················Assert.AreEqual(NDOObjectState.Persistent, ((Reise)rr[i]).NDOObjectState, "4. Wrong state");
280 ············}
281 ········}
282
283 ········[Test]
284 ········public void TestAssignRelatedObjectsNullSave() {
285 ············for(int i = 0; i < 3; i++) {
286 ················m.Hinzufuegen(CreateReise(i.ToString()));
287 ············}
288 ············pm.MakePersistent(m);
289 ············pm.Save();
290 ············IList rr = new ArrayList(m.Reisen);
291 ············m.ErsetzeReisen(null);
292 ············Assert.Null(m.Reisen, "No objects should be there");
293 ············for(int i = 0; i < 3; i++) {
294 ················Assert.AreEqual(NDOObjectState.Deleted, ((Reise)rr[i]).NDOObjectState, "2. Wrong state");
295 ············}
296 ············pm.Save();
297 ············Assert.Null(m.Reisen, "No objects should be there");
298 ············for(int i = 0; i < 3; i++) {
299 ················Assert.AreEqual(NDOObjectState.Transient, ((Reise)rr[i]).NDOObjectState, "4. Wrong state");
300 ············}
301 ········}
302
303 ········[Test]
304 ········public void TestAssignRelatedObjectsNullAbort() {
305 ············for(int i = 0; i < 3; i++) {
306 ················m.Hinzufuegen(CreateReise(i.ToString()));
307 ············}
308 ············pm.MakePersistent(m);
309 ············pm.Save();
310 ············IList rr = new ArrayList(m.Reisen);
311 ············m.ErsetzeReisen(null);
312 ············Assert.Null(m.Reisen, "No objects should be there");
313 ············for(int i = 0; i < 3; i++) {
314 ················Assert.AreEqual(NDOObjectState.Deleted, ((Reise)rr[i]).NDOObjectState, "2. Wrong state");
315 ············}
316 ············pm.Abort();
317 ············Assert.AreEqual(3, m.Reisen.Count, "3. Wrong number of objects");
318 ············for(int i = 0; i < 3; i++) {
319 ················Assert.AreEqual(NDOObjectState.Persistent, ((Reise)rr[i]).NDOObjectState, "4. Wrong state");
320 ············}
321 ········}
322
323 ········[Test]
324 ········public void TestAssignRelatedObjectsSave() {
325 ············for(int i = 0; i < 3; i++) {
326 ················m.Hinzufuegen(CreateReise(i.ToString()));
327 ············}
328 ············pm.MakePersistent(m);
329 ············pm.Save();
330 ············IList neueReisen = new ArrayList();
331 ············Reise nr = CreateReise("Test");
332 ············neueReisen.Add(nr);
333
334 ············IList rr = new ArrayList(m.Reisen);
335 ············m.ErsetzeReisen(neueReisen);
336 ············Assert.AreEqual(1, m.Reisen.Count, "1. Wrong number of objects");
337 ············for(int i = 0; i < 3; i++) {
338 ················Assert.AreEqual(NDOObjectState.Deleted, ((Reise)rr[i]).NDOObjectState, "2. Wrong state");
339 ············}
340 ············Assert.AreEqual(NDOObjectState.Created, nr.NDOObjectState, "3. Wrong state");
341
342 ············pm.Save();
343 ············Assert.AreEqual(1, m.Reisen.Count, "4. Wrong number of objects");
344 ············for(int i = 0; i < 3; i++) {
345 ················Assert.AreEqual(NDOObjectState.Transient, ((Reise)rr[i]).NDOObjectState, "5. Wrong state");
346 ············}
347 ············Assert.AreEqual(NDOObjectState.Persistent, nr.NDOObjectState, "6. Wrong state");
348 ········}
349
350 ········[Test]
351 ········public void TestAssignRelatedObjectsAbort() {
352 ············for(int i = 0; i < 3; i++) {
353 ················m.Hinzufuegen(CreateReise(i.ToString()));
354 ············}
355 ············pm.MakePersistent(m);
356 ············pm.Save();
357 ············IList neueReisen = new ArrayList();
358 ············Reise nr = CreateReise("Test");
359 ············neueReisen.Add(nr);
360
361 ············IList rr = new ArrayList(m.Reisen);
362 ············m.ErsetzeReisen(neueReisen);
363 ············Assert.AreEqual(1, m.Reisen.Count, "1. Wrong number of objects");
364 ············for(int i = 0; i < 3; i++) {
365 ················Assert.AreEqual(NDOObjectState.Deleted, ((Reise)rr[i]).NDOObjectState, "2. Wrong state");
366 ············}
367 ············Assert.AreEqual(NDOObjectState.Created, nr.NDOObjectState, "3. Wrong state");
368
369 ············pm.Abort();
370 ············Assert.AreEqual(3, m.Reisen.Count, "4. Wrong number of objects");
371 ············for(int i = 0; i < 3; i++) {
372 ················Assert.AreEqual(NDOObjectState.Persistent, ((Reise)rr[i]).NDOObjectState, "5. Wrong state");
373 ············}
374 ············Assert.AreEqual(NDOObjectState.Transient, nr.NDOObjectState, "6. Wrong state");
375 ········}
376
377 ········[Test]
378 ········public void TestAddNewReise()
379 ········{
380 ············m.Hinzufuegen(r);
381 ············pm.MakePersistent(m);
382 ············pm.Save();
383 ············pm.UnloadCache();
384 ············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>(pm);
385 ············m = q.ExecuteSingle(true);
386 ············Reise r2 = CreateReise("Schnulli");
387 ············m.Hinzufuegen(r2);
388 ············pm.Save();
389 ············m = q.ExecuteSingle(true);
390 ············Assert.AreEqual(2, m.Reisen.Count, "Count wrong");
391 ········}
392
393 ········[Test]
394 ········public void RefreshReloadsRelation()
395 ········{
396 ············m.Hinzufuegen( r );
397 ············pm.MakePersistent( m );
398 ············pm.Save();
399 ············PersistenceManager pm2 = PmFactory.NewPersistenceManager();
400 ············Mitarbeiter m2 = pm2.Objects<Mitarbeiter>().ResultTable.First();
401 ············Assert.AreEqual( m.Reisen.Count, m2.Reisen.Count );
402 ············Assert.AreEqual( 1, m.Reisen.Count );
403 ············Reise r2 = new Reise() { Zweck = "Test" };
404 ············m2.Hinzufuegen( r2 );
405 ············pm2.Save();
406 ············Assert.AreEqual( 1, m.Reisen.Count );
407 ············pm.Refresh( m );
408 ············Assert.AreEqual( 2, m.Reisen.Count );
409 ········}
410
411 ········[Test]
412 ········public void CanIterateThrougRelatedObjectsWithLinq()
413 ········{
414 ············m.Hinzufuegen( r );
415 ············r = new Reise() { Zweck = "Test" };
416 ············m.Hinzufuegen( r );
417 ············pm.MakePersistent( m );
418 ············pm.Save();
419 ············Assert.AreEqual( 2, m.Reisen.Count );
420 ············ObjectId oid = m.NDOObjectId;
421 ············pm.UnloadCache();
422 ············pm = PmFactory.NewPersistenceManager();
423 ············m = (Mitarbeiter) pm.FindObject( oid );
424 ············Assert.That( m.NDOObjectState == NDOObjectState.Hollow );
425 ············Reise tr = (from reise in m.Reisen where reise.Zweck == "Test" select reise).SingleOrDefault();
426 ············Assert.NotNull( tr );
427 ············Assert.AreEqual( "Test", tr.Zweck );
428 ········}
429
430 ········[Test]
431 ········public void TestHollow() {
432 ············m.Hinzufuegen(r);
433 ············pm.MakePersistent(m);
434 ············pm.Save();
435 ············pm.MakeHollow(m);
436 ············Assert.AreEqual(NDOObjectState.Hollow, m.NDOObjectState, "1: Mitarbeiter should be hollow");
437 ············Assert.AreEqual(NDOObjectState.Persistent, r.NDOObjectState, "1: Reise should be persistent");
438 ············IList reise = m.Reisen;
439
440 ············pm.MakeHollow(m, true);
441 ············Assert.AreEqual(NDOObjectState.Hollow, m.NDOObjectState, "2: Mitarbeiter should be hollow");
442 ············Assert.AreEqual(NDOObjectState.Hollow, r.NDOObjectState, "2: Reise should be hollow");
443
444 ············reise = m.Reisen;
445 ············Assert.AreEqual(NDOObjectState.Persistent, m.NDOObjectState, "3: Mitarbeiter should be persistent");
446 ············Assert.AreEqual(NDOObjectState.Hollow, r.NDOObjectState, "3: Reise should be hollow");
447 ············Assert.AreEqual("ADC", r.Zweck, "3: Reise should have correct Zweck");
448 ············Assert.AreEqual(NDOObjectState.Persistent, r.NDOObjectState, "4: Reise should be persistent");
449 ········}
450
451 ········[Test]
452 ········public void··TestMakeAllHollow() {
453 ············m.Hinzufuegen(r);
454 ············pm.MakePersistent(m);
455 ············pm.Save();
456 ············pm.MakeAllHollow();
457 ············Assert.AreEqual(NDOObjectState.Hollow, m.NDOObjectState, "1: Mitarbeiter should be hollow");
458 ············Assert.AreEqual(NDOObjectState.Hollow, r.NDOObjectState, "1: Reise should be hollow");
459 ············pm.UnloadCache();
460 ········}
461
462 ········[Test]
463 ········public void··TestMakeAllHollowUnsaved() {
464 ············m.Hinzufuegen(r);
465 ············pm.MakePersistent(m);
466 ············pm.MakeAllHollow();··// before save, objects cannot be made hollow. => in locked objects
467 ············Assert.AreEqual(NDOObjectState.Created, m.NDOObjectState, "1: Mitarbeiter should be created");
468 ············Assert.AreEqual(NDOObjectState.Created, r.NDOObjectState, "1: Reise should be created");
469 ········}
470
471 ········[Test]
472 ········public void TestLoadRelatedObjects() {
473 ············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>(pm, null);
474 ············IList dellist = q.Execute();
475 ············pm.Delete(dellist);
476 ············pm.Save();
477 ············pm.UnloadCache();
478
479 ············for(int i = 0; i < 10; i++) {
480 ················m.Hinzufuegen(CreateReise(i.ToString()));
481 ············}
482 ············pm.MakePersistent(m);
483 ············pm.Save();
484 ············pm.MakeHollow(m, true);
485
486 ············IList reisen = new ArrayList(m.Reisen);
487 ············Assert.AreEqual(10, reisen.Count, "Array size should be 10");
488
489 ············for(int i = 0; i < 10; i++) {
490 ················Reise rr = (Reise)reisen[i];
491 ················Assert.AreEqual(NDOObjectState.Hollow, rr.NDOObjectState, "1: Reise should be hollow");
492 //················if (i.ToString()!= rr.Zweck)
493 //················{
494 //····················for (int j = 0; j < 10; j++)
495 //························System.Diagnostics.Debug.WriteLine("Reise: " + ((Reise)reisen[j]).Zweck);
496 //················}
497 #if !ORACLE && !MYSQL && !FIREBIRD
498 ················if (rr.NDOObjectId.Id[0] is Int32)
499 ····················Assert.AreEqual(i.ToString(), rr.Zweck, "2: Reise should be in right order");
500 #endif
501 ············}
502
503
504 ············pm.MakeAllHollow();
505 ············pm.UnloadCache();
506 ············IList reisen2 = m.Reisen;
507 ············for(int i = 0; i < 10; i++) {
508 ················Reise r1 = (Reise)reisen[i];
509 ················Reise r2 = (Reise)reisen2[i];
510 #if !ORACLE && !MYSQL && !FIREBIRD
511 ················if (r1.NDOObjectId.Id[0] is Int32)
512 ················Assert.AreEqual(i.ToString(), r1.Zweck, "3: Reise should be in right order");
513 #endif
514 ················Assert.That(r1 !=··r2, "Objects should be different");
515 ············}
516 ········}
517
518 ········[Test]
519 ········public void TestLoadRelatedObjectsSave() {
520 ············pm.MakePersistent(m);
521 ············pm.Save();
522 ············for(int i = 0; i < 10; i++) {
523 ················m.Hinzufuegen(CreateReise(i.ToString()));
524 ············}
525 ············pm.Save();
526 ············pm.MakeHollow(m, true);
527
528 ············IList reisen = new ArrayList(m.Reisen);
529
530 ············for(int i = 0; i < 10; i++) {
531 ················Reise rr = (Reise)reisen[i];
532 ················Assert.AreEqual(NDOObjectState.Hollow, rr.NDOObjectState, "1: Reise should be hollow");
533 #if !ORACLE && !MYSQL && !FIREBIRD
534 ················if (rr.NDOObjectId.Id[0] is Int32)
535 ····················Assert.AreEqual(i.ToString(), rr.Zweck, "2: Reise should be in right order");
536 #endif
537 ············}
538
539
540 ············pm.MakeAllHollow();
541 ············pm.UnloadCache();
542 ············IList reisen2 = m.Reisen;
543 ············for(int i = 0; i < 10; i++) {
544 ················Reise r1 = (Reise)reisen[i];
545 ················Reise r2 = (Reise)reisen2[i];
546 #if !ORACLE && !MYSQL && !FIREBIRD
547 ················if (r1.NDOObjectId.Id[0] is Int32)
548 ················Assert.AreEqual(i.ToString(), r1.Zweck, "3: Reise should be in right order");
549 #endif
550 ················Assert.That(r1 !=··r2, "Objects should be different");
551 ············}
552 ········}
553
554 ········[Test]
555 ········public void TestExtentRelatedObjects() {
556 ············m.Hinzufuegen(r);
557 ············pm.MakePersistent(m);
558 ············pm.Save();
559 ············IList liste = pm.GetClassExtent(typeof(Mitarbeiter));
560 ············m = (Mitarbeiter)liste[0];
561 ············Assert.AreEqual(NDOObjectState.Persistent, m.NDOObjectState, "1: Mitarbeiter should be persistent");
562 ············Assert.NotNull(m.Reisen, "2. Relation is missing");
563 ············Assert.AreEqual(1, m.Reisen.Count, "3. Wrong number of objects");
564 ············Assert.AreEqual(NDOObjectState.Persistent, ((Reise)m.Reisen[0]).NDOObjectState, "4.: Reise should be hollow");
565
566 ············pm.UnloadCache();
567 ············liste = pm.GetClassExtent(typeof(Mitarbeiter));
568 ············m = (Mitarbeiter)liste[0];
569 ············Assert.AreEqual(NDOObjectState.Hollow, m.NDOObjectState, "5: Mitarbeiter should be hollow");
570 ············Assert.NotNull(m.Reisen, "6. Relation is missing");
571 ············Assert.AreEqual(1, m.Reisen.Count, "7. Wrong number of objects");
572 ············Assert.AreEqual(NDOObjectState.Hollow, ((Reise)m.Reisen[0]).NDOObjectState, "8.: Reise should be hollow");
573
574 ············pm.UnloadCache();
575 ············liste = pm.GetClassExtent(typeof(Mitarbeiter), false);
576 ············m = (Mitarbeiter)liste[0];
577 ············Assert.AreEqual(NDOObjectState.Persistent, m.NDOObjectState, "9: Mitarbeiter should be persistent");
578 ············Assert.NotNull(m.Reisen, "10. Relation is missing");
579 ············Assert.AreEqual(1, m.Reisen.Count, "11. Wrong number of objects");
580 ············Assert.AreEqual(NDOObjectState.Hollow, ((Reise)m.Reisen[0]).NDOObjectState, "12.: Reise should be hollow");
581 ········}
582
583 ········[Test]
584 ········public void TestReiseChangeReload()
585 ········{
586 ············m.Hinzufuegen(r);
587 ············pm.MakePersistent(m);
588 ············pm.Save();
589 ············pm.UnloadCache();
590 ············var provider = pm.NDOMapping.FindClass( typeof( Reise ) ).Provider;
591 ············NDOQuery<Reise> q = new NDOQuery<Reise>(pm, $"zweck LIKE 'A{provider.Wildcard}'");
592 ············r = (Reise) q.ExecuteSingle(true);
593 ············r.Zweck = "NewPurpose";
594 ············pm.VerboseMode = true;
595 ············pm.Save();
596 ············pm.VerboseMode= false;
597 ············NDOQuery<Mitarbeiter> qm = new NDOQuery<Mitarbeiter>(pm);
598 ············m = qm.ExecuteSingle(true);
599 ············Assert.AreEqual(1, m.Reisen.Count, "Count wrong");
600 ············Assert.AreEqual("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("Erzeugt Exception in TearDown")]
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.AreEqual( "Hartmut", m.Vorname, "Vorname falsch" );
676 ············Assert.AreEqual( "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 = pm.ConfigContainer.Resolve<IPersistenceHandler>();
684 ············var h2 = pm.ConfigContainer.Resolve<IPersistenceHandler>();
685 ············Assert.IsTrue( !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.NotNull(ie.Current);
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.AreEqual(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.NotNull(m, "There should be 1 object");
724 ············Assert.AreEqual(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 (42f9eb7)
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
36 namespace NdoUnitTests
37 {
38 ····/// <summary>
39 ····/// Combined Tests of Mitarbeiter and Reise to test uniqueness of object ids.
40 ····/// </summary>
41 ····[TestFixture]
42 ····public class NDOMitarbeiterReiseTests
43 ····{
44 ········public NDOMitarbeiterReiseTests()
45 ········{
46 ········}
47
48 ········private PersistenceManager pm;
49 ········private Mitarbeiter m;
50 ········private Reise r;
51
52 ········[SetUp]
53 ········public void Setup() {
54 ············pm = PmFactory.NewPersistenceManager();
55 ············m = CreateMitarbeiter("Hartmut", "Kocher");
56 ············r = CreateReise("ADC");
57 ········}
58
59 ········[TearDown]
60 ········public void TearDown() {
61 ············pm.Abort();
62 ············pm.UnloadCache();
63 ············IList mitarbeiterListe = pm.GetClassExtent(typeof(Mitarbeiter), true);
64 ············pm.Delete(mitarbeiterListe);
65 ············pm.Save();
66 ············pm.Close();
67 ············pm.GetSqlPassThroughHandler().Execute( "DELETE FROM " + pm.NDOMapping.FindClass( typeof( Reise ) ).TableName );
68 ············pm.Dispose();
69 ········}
70
71 ········[Test]
72 ········public void TestCreateObjects() {
73 ············pm.MakePersistent(m);
74 ············pm.MakePersistent(r);
75 ············Assert.That(!m.NDOObjectId.Equals(r.NDOObjectId), "Ids should be different");
76 ············m = (Mitarbeiter)pm.FindObject(m.NDOObjectId);
77 ············r = (Reise)pm.FindObject(r.NDOObjectId);
78 ········}
79
80 ········[Test]
81 ········public void TestCreateObjectsSave() {
82 ············m.Hinzufuegen(r);
83 ············pm.MakePersistent(m);
84 ············pm.Save();
85 ············Assert.That(!m.NDOObjectId.Equals(r.NDOObjectId), "Ids should be different");
86 ············m = (Mitarbeiter)pm.FindObject(m.NDOObjectId);
87 ············r = (Reise)pm.FindObject(r.NDOObjectId);
88 ············Assert.NotNull(m, "1. Mitarbeiter not found");
89 ············Assert.NotNull(r, "1. Reise not found");
90
91 ············pm.UnloadCache();
92 ············m = (Mitarbeiter)pm.FindObject(m.NDOObjectId);
93 ············r = (Reise)pm.FindObject(r.NDOObjectId);
94 ············Assert.NotNull(m, "2. Mitarbeiter not found");
95 ············Assert.NotNull(r, "2. Reise not found");
96 ········}
97
98 ········[Test]
99 ········public void TestAddObjectSave() {
100 ············pm.MakePersistent(m);
101 ············pm.Save();
102 ············m.Hinzufuegen(r);
103 ············Assert.AreEqual(NDOObjectState.Created, r.NDOObjectState, "1. Wrong state");
104 ············pm.Save();
105 ············m = (Mitarbeiter)pm.FindObject(m.NDOObjectId);
106 ············r = (Reise)pm.FindObject(r.NDOObjectId);
107 ············Assert.NotNull(m, "1. Mitarbeiter not found");
108 ············Assert.NotNull(r, "1. Reise not found");
109 ············Assert.AreEqual(NDOObjectState.Persistent, r.NDOObjectState, "2. Wrong state");
110 ········}
111
112 ········int GetOrdinal(Relation r)
113 ········{
114 ············var t = r.Parent.SystemType;
115 ············Type mcType = t.GetNestedType( "MetaClass", BindingFlags.NonPublic | BindingFlags.Public );
116 ············if (null == mcType)
117 ················throw new NDOException( 13, "Missing nested class 'MetaClass' for type '" + t.Name + "'; the type doesn't seem to be enhanced." );
118 var mc = ( IMetaClass) Activator. CreateInstance( mcType, t ) ;
119 ············return mc.GetRelationOrdinal( r.FieldName );
120 ········}
121
122 ········bool IsLoaded(IPersistentObject pc, Relation r)
123 ········{
124 ············return ((IPersistenceCapable)pc).NDOLoadState.RelationLoadState[GetOrdinal( r )];
125 ········}
126
127 ········[Test]
128 ········public void RestorePreservesRelationLists()
129 ········{
130 ············pm.MakePersistent( m );
131 ············pm.Save();
132 ············m.Hinzufuegen( r );
133 ············pm.Save();
134 ············Assert.AreEqual( 1, m.Reisen.Count );
135
136 ············pm.UnloadCache();
137 ············var m2 = pm.Objects<Mitarbeiter>().Single();
138
139 ············var relation = pm.NDOMapping.FindClass( typeof( Mitarbeiter ) ).FindRelation( "dieReisen" );
140
141 ············Assert.That( !IsLoaded( m2, relation ) );
142 ············var list = m2.Reisen;
143 ············m2.Vorname = "Testxxxx";
144
145 ············Assert.That( IsLoaded( m2, relation ) );
146
147 ············pm.Restore( m2 );
148 ············m2.Nachname = "Testyyyy";
149 ············pm.Save();
150
151 ············Assert.AreEqual( 1, m2.Reisen.Count );
152 ········}
153
154 ········[Test]
155 ········public void TestAddObjectAbort() {
156 ············pm.MakePersistent(m);
157 ············pm.Save();
158 ············m.Hinzufuegen(r);
159 ············Assert.AreEqual(NDOObjectState.Created, r.NDOObjectState, "1. Wrong state");
160 ············Assert.AreEqual(1, m.Reisen.Count, "1. Wrong number of objects");
161 ············pm.Abort();
162 ············Assert.AreEqual(NDOObjectState.Transient, r.NDOObjectState, "2. Wrong state");
163 ············Assert.AreEqual(0, m.Reisen.Count, "2. Wrong number of objects");
164 ········}
165 ········[Test]
166 ········public void TestRemoveObjectSave() {
167 ············pm.MakePersistent(m);
168 ············m.Hinzufuegen(r);
169 ············pm.Save();
170 ············Assert.AreEqual(1, m.Reisen.Count, "1. Wrong number of objects");
171 ············m.Löschen(r);
172 ············Assert.AreEqual(NDOObjectState.Deleted, r.NDOObjectState, "1. Wrong state");
173 ············Assert.AreEqual(0, m.Reisen.Count, "2. Wrong number of objects");
174 ············pm.Save();
175 ············Assert.AreEqual(0, m.Reisen.Count, "3. Wrong number of objects");
176 ············Assert.AreEqual(NDOObjectState.Transient, r.NDOObjectState, "2. Wrong state");
177 ········}
178 ············
179 ········[Test]
180 ········public void TestRemoveObjectAbort() {
181 ············pm.MakePersistent(m);
182 ············m.Hinzufuegen(r);
183 ············pm.Save();
184 ············Assert.AreEqual(1, m.Reisen.Count, "1. Wrong number of objects");
185 ············m.Löschen(r);
186 ············Assert.AreEqual(NDOObjectState.Deleted, r.NDOObjectState, "1. Wrong state");
187 ············Assert.AreEqual(0, m.Reisen.Count, "2. Wrong number of objects");
188 ············pm.Abort();
189 ············Assert.AreEqual(1, m.Reisen.Count, "3. Wrong number of objects");
190 ············Assert.AreEqual(NDOObjectState.Persistent, r.NDOObjectState, "2. Wrong state");
191 ········}
192
193 ········[Test]
194 ········public void TestDeleteSave() {
195 ············pm.MakePersistent(m);
196 ············m.Hinzufuegen(r);
197 ············pm.Save();
198 ············pm.Delete(m);
199 ············Assert.AreEqual(NDOObjectState.Deleted, m.NDOObjectState, "1. Wrong state");
200 ············Assert.AreEqual(NDOObjectState.Deleted, r.NDOObjectState, "2. Wrong state");
201 ············pm.Save();
202 ············Assert.AreEqual(NDOObjectState.Transient, m.NDOObjectState, "1. Wrong state");
203 ············Assert.AreEqual(NDOObjectState.Transient, r.NDOObjectState, "2. Wrong state");
204 ········}
205
206
207
208 ········[Test]
209 ········public void TestDeleteAbort() {
210 ············pm.MakePersistent(m);
211 ············m.Hinzufuegen(r);
212 ············pm.Save();
213 ············pm.Delete(m);
214 ············Assert.AreEqual(NDOObjectState.Deleted, m.NDOObjectState, "1. Wrong state");
215 ············Assert.AreEqual(NDOObjectState.Deleted, r.NDOObjectState, "2. Wrong state");
216 ············pm.Abort();
217 ············Assert.AreEqual(NDOObjectState.Persistent, m.NDOObjectState, "1. Wrong state");
218 ············Assert.AreEqual(NDOObjectState.Persistent, r.NDOObjectState, "2. Wrong state");
219 ········}
220
221 ········[Test]
222 ········public void TestAddRemoveSave() {
223 ············pm.MakePersistent(m);
224 ············pm.Save();
225 ············m.Hinzufuegen(r);
226 ············m.Löschen(r);
227 ············Assert.AreEqual(NDOObjectState.Transient, r.NDOObjectState, "1. Wrong state");
228 ············pm.Save();
229 ············Assert.AreEqual(NDOObjectState.Transient, r.NDOObjectState, "2. Wrong state");
230 ········}
231
232 ········[Test]
233 ········public void TestAddRemoveAbort() {
234 ············pm.MakePersistent(m);
235 ············pm.Save();
236 ············m.Hinzufuegen(r);
237 ············m.Löschen(r);
238 ············Assert.AreEqual(NDOObjectState.Transient, r.NDOObjectState, "1. Wrong state");
239 ············pm.Abort();
240 ············Assert.AreEqual(NDOObjectState.Transient, r.NDOObjectState, "2. Wrong state");
241 ········}
242
243 ········[Test]
244 ········public void TestClearRelatedObjectsSave() {
245 ············for(int i = 0; i < 10; i++) {
246 ················m.Hinzufuegen(CreateReise(i.ToString()));
247 ············}
248 ············pm.MakePersistent(m);
249 ············pm.Save();
250 ············IList rr = new ArrayList(m.Reisen);
251 ············m.LöscheReisen();
252 ············Assert.AreEqual(0, m.Reisen.Count, "1. Wrong number of objects");
253 ············for(int i = 0; i < 10; i++) {
254 ················Assert.AreEqual(NDOObjectState.Deleted, ((Reise)rr[i]).NDOObjectState, "2. Wrong state");
255 ············}
256 ············pm.Save();
257 ············Assert.AreEqual(0, m.Reisen.Count, "3. Wrong number of objects");
258 ············for(int i = 0; i < 10; i++) {
259 ················Assert.AreEqual(NDOObjectState.Transient, ((Reise)rr[i]).NDOObjectState, "4. Wrong state");
260 ············}
261 ········}
262
263 ········[Test]
264 ········public void TestClearRelatedObjectsAbort() {
265 ············for(int i = 0; i < 10; i++) {
266 ················m.Hinzufuegen(CreateReise(i.ToString()));
267 ············}
268 ············pm.MakePersistent(m);
269 ············pm.Save();
270 ············IList rr = new ArrayList(m.Reisen);
271 ············m.LöscheReisen();
272 ············Assert.AreEqual(0, m.Reisen.Count, "1. Wrong number of objects");
273 ············for(int i = 0; i < 10; i++) {
274 ················Assert.AreEqual(NDOObjectState.Deleted, ((Reise)rr[i]).NDOObjectState, "2. Wrong state");
275 ············}
276 ············pm.Abort();
277 ············Assert.AreEqual(10, m.Reisen.Count, "3. Wrong number of objects");
278 ············for(int i = 0; i < 10; i++) {
279 ················Assert.AreEqual(NDOObjectState.Persistent, ((Reise)rr[i]).NDOObjectState, "4. Wrong state");
280 ············}
281 ········}
282
283 ········[Test]
284 ········public void TestAssignRelatedObjectsNullSave() {
285 ············for(int i = 0; i < 3; i++) {
286 ················m.Hinzufuegen(CreateReise(i.ToString()));
287 ············}
288 ············pm.MakePersistent(m);
289 ············pm.Save();
290 ············IList rr = new ArrayList(m.Reisen);
291 ············m.ErsetzeReisen(null);
292 ············Assert.Null(m.Reisen, "No objects should be there");
293 ············for(int i = 0; i < 3; i++) {
294 ················Assert.AreEqual(NDOObjectState.Deleted, ((Reise)rr[i]).NDOObjectState, "2. Wrong state");
295 ············}
296 ············pm.Save();
297 ············Assert.Null(m.Reisen, "No objects should be there");
298 ············for(int i = 0; i < 3; i++) {
299 ················Assert.AreEqual(NDOObjectState.Transient, ((Reise)rr[i]).NDOObjectState, "4. Wrong state");
300 ············}
301 ········}
302
303 ········[Test]
304 ········public void TestAssignRelatedObjectsNullAbort() {
305 ············for(int i = 0; i < 3; i++) {
306 ················m.Hinzufuegen(CreateReise(i.ToString()));
307 ············}
308 ············pm.MakePersistent(m);
309 ············pm.Save();
310 ············IList rr = new ArrayList(m.Reisen);
311 ············m.ErsetzeReisen(null);
312 ············Assert.Null(m.Reisen, "No objects should be there");
313 ············for(int i = 0; i < 3; i++) {
314 ················Assert.AreEqual(NDOObjectState.Deleted, ((Reise)rr[i]).NDOObjectState, "2. Wrong state");
315 ············}
316 ············pm.Abort();
317 ············Assert.AreEqual(3, m.Reisen.Count, "3. Wrong number of objects");
318 ············for(int i = 0; i < 3; i++) {
319 ················Assert.AreEqual(NDOObjectState.Persistent, ((Reise)rr[i]).NDOObjectState, "4. Wrong state");
320 ············}
321 ········}
322
323 ········[Test]
324 ········public void TestAssignRelatedObjectsSave() {
325 ············for(int i = 0; i < 3; i++) {
326 ················m.Hinzufuegen(CreateReise(i.ToString()));
327 ············}
328 ············pm.MakePersistent(m);
329 ············pm.Save();
330 ············IList neueReisen = new ArrayList();
331 ············Reise nr = CreateReise("Test");
332 ············neueReisen.Add(nr);
333
334 ············IList rr = new ArrayList(m.Reisen);
335 ············m.ErsetzeReisen(neueReisen);
336 ············Assert.AreEqual(1, m.Reisen.Count, "1. Wrong number of objects");
337 ············for(int i = 0; i < 3; i++) {
338 ················Assert.AreEqual(NDOObjectState.Deleted, ((Reise)rr[i]).NDOObjectState, "2. Wrong state");
339 ············}
340 ············Assert.AreEqual(NDOObjectState.Created, nr.NDOObjectState, "3. Wrong state");
341
342 ············pm.Save();
343 ············Assert.AreEqual(1, m.Reisen.Count, "4. Wrong number of objects");
344 ············for(int i = 0; i < 3; i++) {
345 ················Assert.AreEqual(NDOObjectState.Transient, ((Reise)rr[i]).NDOObjectState, "5. Wrong state");
346 ············}
347 ············Assert.AreEqual(NDOObjectState.Persistent, nr.NDOObjectState, "6. Wrong state");
348 ········}
349
350 ········[Test]
351 ········public void TestAssignRelatedObjectsAbort() {
352 ············for(int i = 0; i < 3; i++) {
353 ················m.Hinzufuegen(CreateReise(i.ToString()));
354 ············}
355 ············pm.MakePersistent(m);
356 ············pm.Save();
357 ············IList neueReisen = new ArrayList();
358 ············Reise nr = CreateReise("Test");
359 ············neueReisen.Add(nr);
360
361 ············IList rr = new ArrayList(m.Reisen);
362 ············m.ErsetzeReisen(neueReisen);
363 ············Assert.AreEqual(1, m.Reisen.Count, "1. Wrong number of objects");
364 ············for(int i = 0; i < 3; i++) {
365 ················Assert.AreEqual(NDOObjectState.Deleted, ((Reise)rr[i]).NDOObjectState, "2. Wrong state");
366 ············}
367 ············Assert.AreEqual(NDOObjectState.Created, nr.NDOObjectState, "3. Wrong state");
368
369 ············pm.Abort();
370 ············Assert.AreEqual(3, m.Reisen.Count, "4. Wrong number of objects");
371 ············for(int i = 0; i < 3; i++) {
372 ················Assert.AreEqual(NDOObjectState.Persistent, ((Reise)rr[i]).NDOObjectState, "5. Wrong state");
373 ············}
374 ············Assert.AreEqual(NDOObjectState.Transient, nr.NDOObjectState, "6. Wrong state");
375 ········}
376
377 ········[Test]
378 ········public void TestAddNewReise()
379 ········{
380 ············m.Hinzufuegen(r);
381 ············pm.MakePersistent(m);
382 ············pm.Save();
383 ············pm.UnloadCache();
384 ············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>(pm);
385 ············m = q.ExecuteSingle(true);
386 ············Reise r2 = CreateReise("Schnulli");
387 ············m.Hinzufuegen(r2);
388 ············pm.Save();
389 ············m = q.ExecuteSingle(true);
390 ············Assert.AreEqual(2, m.Reisen.Count, "Count wrong");
391 ········}
392
393 ········[Test]
394 ········public void RefreshReloadsRelation()
395 ········{
396 ············m.Hinzufuegen( r );
397 ············pm.MakePersistent( m );
398 ············pm.Save();
399 ············PersistenceManager pm2 = PmFactory.NewPersistenceManager();
400 ············Mitarbeiter m2 = pm2.Objects<Mitarbeiter>().ResultTable.First();
401 ············Assert.AreEqual( m.Reisen.Count, m2.Reisen.Count );
402 ············Assert.AreEqual( 1, m.Reisen.Count );
403 ············Reise r2 = new Reise() { Zweck = "Test" };
404 ············m2.Hinzufuegen( r2 );
405 ············pm2.Save();
406 ············Assert.AreEqual( 1, m.Reisen.Count );
407 ············pm.Refresh( m );
408 ············Assert.AreEqual( 2, m.Reisen.Count );
409 ········}
410
411 ········[Test]
412 ········public void CanIterateThrougRelatedObjectsWithLinq()
413 ········{
414 ············m.Hinzufuegen( r );
415 ············r = new Reise() { Zweck = "Test" };
416 ············m.Hinzufuegen( r );
417 ············pm.MakePersistent( m );
418 ············pm.Save();
419 ············Assert.AreEqual( 2, m.Reisen.Count );
420 ············ObjectId oid = m.NDOObjectId;
421 ············pm.UnloadCache();
422 ············pm = PmFactory.NewPersistenceManager();
423 ············m = (Mitarbeiter) pm.FindObject( oid );
424 ············Assert.That( m.NDOObjectState == NDOObjectState.Hollow );
425 ············Reise tr = (from reise in m.Reisen where reise.Zweck == "Test" select reise).SingleOrDefault();
426 ············Assert.NotNull( tr );
427 ············Assert.AreEqual( "Test", tr.Zweck );
428 ········}
429
430 ········[Test]
431 ········public void TestHollow() {
432 ············m.Hinzufuegen(r);
433 ············pm.MakePersistent(m);
434 ············pm.Save();
435 ············pm.MakeHollow(m);
436 ············Assert.AreEqual(NDOObjectState.Hollow, m.NDOObjectState, "1: Mitarbeiter should be hollow");
437 ············Assert.AreEqual(NDOObjectState.Persistent, r.NDOObjectState, "1: Reise should be persistent");
438 ············IList reise = m.Reisen;
439
440 ············pm.MakeHollow(m, true);
441 ············Assert.AreEqual(NDOObjectState.Hollow, m.NDOObjectState, "2: Mitarbeiter should be hollow");
442 ············Assert.AreEqual(NDOObjectState.Hollow, r.NDOObjectState, "2: Reise should be hollow");
443
444 ············reise = m.Reisen;
445 ············Assert.AreEqual(NDOObjectState.Persistent, m.NDOObjectState, "3: Mitarbeiter should be persistent");
446 ············Assert.AreEqual(NDOObjectState.Hollow, r.NDOObjectState, "3: Reise should be hollow");
447 ············Assert.AreEqual("ADC", r.Zweck, "3: Reise should have correct Zweck");
448 ············Assert.AreEqual(NDOObjectState.Persistent, r.NDOObjectState, "4: Reise should be persistent");
449 ········}
450
451 ········[Test]
452 ········public void··TestMakeAllHollow() {
453 ············m.Hinzufuegen(r);
454 ············pm.MakePersistent(m);
455 ············pm.Save();
456 ············pm.MakeAllHollow();
457 ············Assert.AreEqual(NDOObjectState.Hollow, m.NDOObjectState, "1: Mitarbeiter should be hollow");
458 ············Assert.AreEqual(NDOObjectState.Hollow, r.NDOObjectState, "1: Reise should be hollow");
459 ············pm.UnloadCache();
460 ········}
461
462 ········[Test]
463 ········public void··TestMakeAllHollowUnsaved() {
464 ············m.Hinzufuegen(r);
465 ············pm.MakePersistent(m);
466 ············pm.MakeAllHollow();··// before save, objects cannot be made hollow. => in locked objects
467 ············Assert.AreEqual(NDOObjectState.Created, m.NDOObjectState, "1: Mitarbeiter should be created");
468 ············Assert.AreEqual(NDOObjectState.Created, r.NDOObjectState, "1: Reise should be created");
469 ········}
470
471 ········[Test]
472 ········public void TestLoadRelatedObjects() {
473 ············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>(pm, null);
474 ············IList dellist = q.Execute();
475 ············pm.Delete(dellist);
476 ············pm.Save();
477 ············pm.UnloadCache();
478
479 ············for(int i = 0; i < 10; i++) {
480 ················m.Hinzufuegen(CreateReise(i.ToString()));
481 ············}
482 ············pm.MakePersistent(m);
483 ············pm.Save();
484 ············pm.MakeHollow(m, true);
485
486 ············IList reisen = new ArrayList(m.Reisen);
487 ············Assert.AreEqual(10, reisen.Count, "Array size should be 10");
488
489 ············for(int i = 0; i < 10; i++) {
490 ················Reise rr = (Reise)reisen[i];
491 ················Assert.AreEqual(NDOObjectState.Hollow, rr.NDOObjectState, "1: Reise should be hollow");
492 //················if (i.ToString()!= rr.Zweck)
493 //················{
494 //····················for (int j = 0; j < 10; j++)
495 //························System.Diagnostics.Debug.WriteLine("Reise: " + ((Reise)reisen[j]).Zweck);
496 //················}
497 #if !ORACLE && !MYSQL && !FIREBIRD
498 ················if (rr.NDOObjectId.Id[0] is Int32)
499 ····················Assert.AreEqual(i.ToString(), rr.Zweck, "2: Reise should be in right order");
500 #endif
501 ············}
502
503
504 ············pm.MakeAllHollow();
505 ············pm.UnloadCache();
506 ············IList reisen2 = m.Reisen;
507 ············for(int i = 0; i < 10; i++) {
508 ················Reise r1 = (Reise)reisen[i];
509 ················Reise r2 = (Reise)reisen2[i];
510 #if !ORACLE && !MYSQL && !FIREBIRD
511 ················if (r1.NDOObjectId.Id[0] is Int32)
512 ················Assert.AreEqual(i.ToString(), r1.Zweck, "3: Reise should be in right order");
513 #endif
514 ················Assert.That(r1 !=··r2, "Objects should be different");
515 ············}
516 ········}
517
518 ········[Test]
519 ········public void TestLoadRelatedObjectsSave() {
520 ············pm.MakePersistent(m);
521 ············pm.Save();
522 ············for(int i = 0; i < 10; i++) {
523 ················m.Hinzufuegen(CreateReise(i.ToString()));
524 ············}
525 ············pm.Save();
526 ············pm.MakeHollow(m, true);
527
528 ············IList reisen = new ArrayList(m.Reisen);
529
530 ············for(int i = 0; i < 10; i++) {
531 ················Reise rr = (Reise)reisen[i];
532 ················Assert.AreEqual(NDOObjectState.Hollow, rr.NDOObjectState, "1: Reise should be hollow");
533 #if !ORACLE && !MYSQL && !FIREBIRD
534 ················if (rr.NDOObjectId.Id[0] is Int32)
535 ····················Assert.AreEqual(i.ToString(), rr.Zweck, "2: Reise should be in right order");
536 #endif
537 ············}
538
539
540 ············pm.MakeAllHollow();
541 ············pm.UnloadCache();
542 ············IList reisen2 = m.Reisen;
543 ············for(int i = 0; i < 10; i++) {
544 ················Reise r1 = (Reise)reisen[i];
545 ················Reise r2 = (Reise)reisen2[i];
546 #if !ORACLE && !MYSQL && !FIREBIRD
547 ················if (r1.NDOObjectId.Id[0] is Int32)
548 ················Assert.AreEqual(i.ToString(), r1.Zweck, "3: Reise should be in right order");
549 #endif
550 ················Assert.That(r1 !=··r2, "Objects should be different");
551 ············}
552 ········}
553
554 ········[Test]
555 ········public void TestExtentRelatedObjects() {
556 ············m.Hinzufuegen(r);
557 ············pm.MakePersistent(m);
558 ············pm.Save();
559 ············IList liste = pm.GetClassExtent(typeof(Mitarbeiter));
560 ············m = (Mitarbeiter)liste[0];
561 ············Assert.AreEqual(NDOObjectState.Persistent, m.NDOObjectState, "1: Mitarbeiter should be persistent");
562 ············Assert.NotNull(m.Reisen, "2. Relation is missing");
563 ············Assert.AreEqual(1, m.Reisen.Count, "3. Wrong number of objects");
564 ············Assert.AreEqual(NDOObjectState.Persistent, ((Reise)m.Reisen[0]).NDOObjectState, "4.: Reise should be hollow");
565
566 ············pm.UnloadCache();
567 ············liste = pm.GetClassExtent(typeof(Mitarbeiter));
568 ············m = (Mitarbeiter)liste[0];
569 ············Assert.AreEqual(NDOObjectState.Hollow, m.NDOObjectState, "5: Mitarbeiter should be hollow");
570 ············Assert.NotNull(m.Reisen, "6. Relation is missing");
571 ············Assert.AreEqual(1, m.Reisen.Count, "7. Wrong number of objects");
572 ············Assert.AreEqual(NDOObjectState.Hollow, ((Reise)m.Reisen[0]).NDOObjectState, "8.: Reise should be hollow");
573
574 ············pm.UnloadCache();
575 ············liste = pm.GetClassExtent(typeof(Mitarbeiter), false);
576 ············m = (Mitarbeiter)liste[0];
577 ············Assert.AreEqual(NDOObjectState.Persistent, m.NDOObjectState, "9: Mitarbeiter should be persistent");
578 ············Assert.NotNull(m.Reisen, "10. Relation is missing");
579 ············Assert.AreEqual(1, m.Reisen.Count, "11. Wrong number of objects");
580 ············Assert.AreEqual(NDOObjectState.Hollow, ((Reise)m.Reisen[0]).NDOObjectState, "12.: Reise should be hollow");
581 ········}
582
583 ········[Test]
584 ········public void TestReiseChangeReload()
585 ········{
586 ············m.Hinzufuegen(r);
587 ············pm.MakePersistent(m);
588 ············pm.Save();
589 ············pm.UnloadCache();
590 ············var provider = pm.NDOMapping.FindClass( typeof( Reise ) ).Provider;
591 ············NDOQuery<Reise> q = new NDOQuery<Reise>(pm, $"zweck LIKE 'A{provider.Wildcard}'");
592 ············r = (Reise) q.ExecuteSingle(true);
593 ············r.Zweck = "NewPurpose";
594 ············pm.VerboseMode = true;
595 ············pm.Save();
596 ············pm.VerboseMode= false;
597 ············NDOQuery<Mitarbeiter> qm = new NDOQuery<Mitarbeiter>(pm);
598 ············m = qm.ExecuteSingle(true);
599 ············Assert.AreEqual(1, m.Reisen.Count, "Count wrong");
600 ············Assert.AreEqual("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("Erzeugt Exception in TearDown")]
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.AreEqual( "Hartmut", m.Vorname, "Vorname falsch" );
676 ············Assert.AreEqual( "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 = pm.ConfigContainer.Resolve<IPersistenceHandler>();
684 ············var h2 = pm.ConfigContainer.Resolve<IPersistenceHandler>();
685 ············Assert.IsTrue( !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.NotNull(ie.Current);
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.AreEqual(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.NotNull(m, "There should be 1 object");
724 ············Assert.AreEqual(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