Datei: IntegrationTests/NdoUnitTests/NDOMitarbeiterReiseTests.cs

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