Datei: IntegrationTests/IntegrationTests/PolymorphicWTable.cs

Last Commit (08b23aa)
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.Diagnostics;
25 using System.Collections;
26 using NUnit.Framework;
27 using NDO;
28 using NDO.Mapping;
29 using Reisekosten;
30 using Reisekosten.Personal;
31 using PureBusinessClasses;
32 using NDO.Query;
33 using System.Linq;
34 using System.Collections.Generic;
35
36 namespace NdoUnitTests {
37 ····/// <summary>
38 ····/// Polymorphic tests.
39 ····/// </summary>
40 ····[TestFixture]
41 ····public class PolymorphicWTable : NDOTest
42 ····{
43 ········public PolymorphicWTable() {
44 ········}
45
46 ········private Reise r;
47 ········private Kostenpunkt kp;
48 ········private ICollection onSavingCollection = null;
49
50 ········[SetUp]
51 ········public void Setup() {
52 ············r = CreateReise("ADC");
53 ············kp = CreateBeleg();
54 ········}
55
56 ········[TearDown]
57 ········public void TearDown() {
58 var pm = PmFactory. NewPersistenceManager( ) ;
 
59 ············pm.TransactionMode = TransactionMode.None;
60
61 ············//pm.UnloadCache();
62 ············IList reiseliste = pm.GetClassExtent(typeof(Reise), true);
63 pm. Delete( reiseliste) ;
64 ············pm.Save();
65 ············pm.UnloadCache();
66 ············IQuery q;
67 ············IList liste;
68
69 ············// We can't delete orphan Beleg object with NDO, so use direct Sql statements
70 ············using (var handler = pm.GetSqlPassThroughHandler())
71 ············{
72 ················var sql = "DELETE FROM " + pm.NDOMapping.FindClass( typeof( Beleg ) ).TableName;
73 ················handler.Execute( sql );
74 ············}
75
76 q = new NDOQuery<Contact>( pm) ;
77 ············liste = q.Execute();
78 pm. Delete( liste) ;
79 ············pm.Save();
80 q = new NDOQuery<Adresse>( pm) ;
81 ············liste = q.Execute();
82 pm. Delete( liste) ;
83 ············pm.Save();
84 pm. Dispose( ) ;
85 ········}
86
87 ········[Test]
88 public void TestCreateObjects( ) {
89 var pm = PmFactory. NewPersistenceManager( ) ;
90 pm. MakePersistent( r) ;
91 r. AddKostenpunkt( kp) ;
92 Assert. That( NDOObjectState. Created == kp. NDOObjectState, "Beleg should be Created: ") ;
 
 
 
93 ········}
94
95
96 ········[Test]
97 public void TestCreateObjects2( ) {
98 var pm = PmFactory. NewPersistenceManager( ) ;
99 r. AddKostenpunkt( kp) ;
100 pm. MakePersistent( r) ;
101 Assert. That( NDOObjectState. Created == kp. NDOObjectState, "Beleg should be Created: ") ;
 
 
 
102 ········}
103
104 ········[Test]
105 public void TestCreateObjectsSave( ) {
106 var pm = PmFactory. NewPersistenceManager( ) ;
107 r. AddKostenpunkt( kp) ;
108 pm. MakePersistent( r) ;
 
 
109 ············pm.Save();
110
111 ············pm.UnloadCache();
112 r = ( Reise) pm. FindObject( r. NDOObjectId) ;
113 Assert. That( r != null, "Reise not found") ;
114 Assert. That( 1 == r. Kostenpunkte. Count ) ;
115 Assert. That( r. Kostenpunkte[0] != null, "Beleg not found") ;
 
116 ········}
117
118 ········[Test]
119 public void TestCreateManyObjectsSave( ) {
120 var pm = PmFactory. NewPersistenceManager( ) ;
121 r. AddKostenpunkt( kp) ;
122 pm. MakePersistent( r) ;
 
 
123 ············pm.Save();
124
125 r. AddKostenpunkt( CreateBeleg( 50) ) ;
126 r. AddKostenpunkt( CreateBeleg( 50) ) ;
127 ············pm.Save();
128 ············pm.UnloadCache();
129 r = ( Reise) pm. FindObject( r. NDOObjectId) ;
130 Assert. That( r != null, "Reise not found") ;
131 Assert. That( 3 == r. Kostenpunkte. Count, "Anzahl Belege: " ) ;
132 Assert. That( r. Kostenpunkte[0] != null, "Beleg not found") ;
133 Assert. That( 300 == r. Gesamtkosten, "Gesamtkosten: ") ;
 
134 ········}
 
135 ········[Test]
136 public void TestCreatePolymorphicObjectsSave( ) {
137 var pm = PmFactory. NewPersistenceManager( ) ;
138 r. AddKostenpunkt( kp) ;
139 pm. MakePersistent( r) ;
 
 
140 ············pm.Save();
141
142 r. AddKostenpunkt( CreatePkw( 100) ) ;
143 r. AddKostenpunkt( CreateBeleg( 50) ) ;
144 ············pm.Save();
145 ············pm.UnloadCache();
146 r = ( Reise) pm. FindObject( r. NDOObjectId) ;
147 Assert. That( r != null, "Reise not found") ;
148 Assert. That( r. Kostenpunkte[0] != null, "Beleg not found") ;
149 Assert. That( 3 == r. Kostenpunkte. Count, "Anzahl Belege: ") ;
150 Assert. That( 300 == r. Gesamtkosten, "Gesamtkosten: ") ;
151 Assert. That( typeof( Beleg) == r. Kostenpunkte[0]. GetType( ) , "Type") ;
152 Assert. That( typeof( PKWFahrt) == r. Kostenpunkte[1]. GetType( ) , "Type") ;
153 Assert. That( typeof( Beleg) == r. Kostenpunkte[2]. GetType( ) , "Type") ;
154
155 ········}
156
157 ········[Test]
158 ········public void TestPolymorphicQuery()
 
 
159 ········{
160 // Debug. WriteLine( "TestPolymorphicQuery") ;
161 var pm = PmFactory. NewPersistenceManager( ) ;
162 r. AddKostenpunkt( kp) ;
163 r. AddKostenpunkt( CreatePkw( 100) ) ;
164 ············r.AddKostenpunkt(CreateBeleg(50));
165 ············pm.MakePersistent(r);
166 ············pm.Save();
167 ············pm.UnloadCache();
168
169 ············IQuery q = new NDOQuery<Kostenpunkt>(pm, null);
170 ············IList l = q.Execute();
171 Assert. That( 3 == l. Count, "Anzahl Belege: ") ;
172 ········}
 
173
174
175 ········[Test]
176 ········public void TestPolymorphicAggregateQuery()
 
 
177 ········{
178 // Debug. WriteLine( "TestPolymorphicAggregateQuery") ;
179 var pm = PmFactory. NewPersistenceManager( ) ;
180 r. AddKostenpunkt( kp) ;
181 r. AddKostenpunkt( CreatePkw( 100) ) ;
182 ············r.AddKostenpunkt(CreateBeleg(50));
183 ············pm.MakePersistent(r);
184 ············if (r.NDOObjectId.Id[0] is Int32)
185 ············{
186 ················pm.Save();
187 ················decimal sum = 0m;
188 foreach( Kostenpunkt kp2 in r. Kostenpunkte)
189 ················{
190 sum += ( Int32) kp2. NDOObjectId. Id[0];
191 ················}
192
193 ················IQuery q = new NDOQuery<Kostenpunkt>(pm, null);
194 ················decimal newsum = (decimal)q.ExecuteAggregate("oid", AggregateType.Sum);
195 Assert. That( sum == newsum, "Summe stimmt nicht: ") ;
196 ················decimal newcount = (decimal)q.ExecuteAggregate("oid", AggregateType.Count);
197 Assert. That( 3 == newcount, "Summe stimmt nicht: ") ;
198 ············}
199 ········}
 
200
201 ········[Test]
202 ········public void TestOnSavingEvent()
 
 
203 ········{
204 // Debug. WriteLine( "TestOnSavingEvent") ;
205 var pm = PmFactory. NewPersistenceManager( ) ;
206 r. AddKostenpunkt( kp) ;
207 r. AddKostenpunkt( CreatePkw( 100) ) ;
208 r. AddKostenpunkt( CreateBeleg( 50) ) ;
209 ············pm.MakePersistent(r);
210 ············pm.OnSavingEvent += new OnSavingHandler(this.OnSavingListener);
211 ············pm.Save();
212 Assert. That( this. onSavingCollection != null, "onSavingCollection is null") ;
 
213 ········}
214
215 ········private void OnSavingListener(ICollection c)
216 ········{
217 ············this.onSavingCollection = c;
218 ········}
219
220
221
222 ········[Ignore("Future Feature")]
223 ········[Test]
224 ········public void TestPolymorphicQueryWithSql()
225 ········{
226 var pm = PmFactory. NewPersistenceManager( ) ;
227 r. AddKostenpunkt( kp) ;
228 r. AddKostenpunkt( CreatePkw( 100) ) ;
229 r. AddKostenpunkt( CreateBeleg( 50) ) ;
230 pm. MakePersistent( r) ;
 
231 ············pm.Save();
232 ············pm.UnloadCache();
233
234 ············string sql = @"SELECT DISTINCT Reise.ID FROM Reise, relBelegKostenpunkt, PKWFahrt, Beleg WHERE ((relBelegKostenpunkt.IDReise = Reise.ID AND relBelegKostenpunkt.TCBeleg = 4) AND PKWFahrt.ID != 0 ) OR··((relBelegKostenpunkt.IDReise = Reise.ID AND relBelegKostenpunkt.TCBeleg = 3) AND Beleg.ID != 0)";
235 ············//string sql = "select distinct Reise.ID from Reise";
236 ············//string sql = "select * from Reise";
237
238 ············NDOQuery<Reise> q = new NDOQuery<Reise>(pm, sql, true, QueryLanguage.Sql);
239 ············//System.Diagnostics.Debug.WriteLine(q.GeneratedQuery);
240
241 ············IList l = q.Execute();
242 Assert. That( 1 == l. Count, "Anzahl Reisen: ") ;
 
243 ········}
244
245 ········
246 ········[Test]
247 ········public void TestAddObjectSave() {
248 var pm = PmFactory. NewPersistenceManager( ) ;
249 pm. MakePersistent( r) ;
 
250 ············pm.Save();
251 r. AddKostenpunkt( kp) ;
252 Assert. That( NDOObjectState. Created == kp. NDOObjectState, "1. Wrong state") ;
253 ············pm.Save();
254 r = ( Reise) pm. FindObject( r. NDOObjectId) ;
255 kp = ( Kostenpunkt) pm. FindObject( kp. NDOObjectId) ;
256 Assert. That( r != null, "1. Reise not found") ;
257 Assert. That( kp != null, "2. Beleg not found") ;
258 Assert. That( NDOObjectState. Persistent == kp. NDOObjectState, "3. Wrong state") ;
259 Assert. That( DateTime. Now. Date == kp. Datum, "Wrong data") ;
 
260 ········}
261 ············
262 ········[Test]
263 public void TestAddObjectAbort( ) {
264 var pm = PmFactory. NewPersistenceManager( ) ;
265 pm. MakePersistent( r) ;
 
 
266 ············pm.Save();
267 r. AddKostenpunkt( kp) ;
268 Assert. That( NDOObjectState. Created == kp. NDOObjectState, "1. Wrong state") ;
269 Assert. That( 1 == r. Kostenpunkte. Count, "1. Wrong number of objects") ;
270 ············pm.Abort();
271 Assert. That( NDOObjectState. Transient == kp. NDOObjectState, "2. Wrong state") ;
272 Assert. That( 0 == r. Kostenpunkte. Count, "2. Wrong number of objects") ;
 
273 ········}
 
274 ········[Test]
275 public void TestRemoveObjectSave( ) {
276 var pm = PmFactory. NewPersistenceManager( ) ;
277 pm. MakePersistent( r) ;
278 r. AddKostenpunkt( kp) ;
 
 
279 ············pm.Save();
280 Assert. That( 1 == r. Kostenpunkte. Count, "1. Wrong number of objects") ;
281 r. Löschen( kp) ;
282 Assert. That( NDOObjectState. Deleted == kp. NDOObjectState, "1. Wrong state") ;
283 Assert. That( 0 == r. Kostenpunkte. Count, "2. Wrong number of objects") ;
284 ············pm.Save();
285 Assert. That( 0 == r. Kostenpunkte. Count, "3. Wrong number of objects") ;
286 Assert. That( NDOObjectState. Transient == kp. NDOObjectState, "2. Wrong state") ;
287 ········}
 
288 ············
289 ········[Test]
290 public void TestRemoveObjectAbort( ) {
291 var pm = PmFactory. NewPersistenceManager( ) ;
292 pm. MakePersistent( r) ;
293 r. AddKostenpunkt( kp) ;
 
 
294 ············pm.Save();
295 Assert. That( 1 == r. Kostenpunkte. Count, "1. Wrong number of objects") ;
296 r. Löschen( kp) ;
297 Assert. That( NDOObjectState. Deleted == kp. NDOObjectState, "1. Wrong state") ;
298 Assert. That( 0 == r. Kostenpunkte. Count, "2. Wrong number of objects") ;
299 ············pm.Abort();
300 Assert. That( 1 == r. Kostenpunkte. Count, "3. Wrong number of objects") ;
301 Assert. That( NDOObjectState. Persistent == kp. NDOObjectState, "2. Wrong state") ;
 
302 ········}
303
304 ········[Test]
305 public void TestDeleteSave( ) {
306 var pm = PmFactory. NewPersistenceManager( ) ;
307 pm. MakePersistent( r) ;
308 r. AddKostenpunkt( kp) ;
 
 
309 ············pm.Save();
310 pm. Delete( r) ;
311 Assert. That( NDOObjectState. Deleted == r. NDOObjectState, "1. Wrong state") ;
312 Assert. That( NDOObjectState. Deleted == kp. NDOObjectState, "2. Wrong state") ;
313 ············pm.Save();
314 Assert. That( NDOObjectState. Transient == r. NDOObjectState, "1. Wrong state") ;
315 Assert. That( NDOObjectState. Transient == kp. NDOObjectState, "2. Wrong state") ;
 
316 ········}
317
318
319
320 ········[Test]
321 public void TestDeleteAbort( ) {
322 var pm = PmFactory. NewPersistenceManager( ) ;
323 pm. MakePersistent( r) ;
324 r. AddKostenpunkt( kp) ;
 
 
325 ············pm.Save();
326 pm. Delete( r) ;
327 Assert. That( NDOObjectState. Deleted == r. NDOObjectState, "1. Wrong state") ;
328 Assert. That( NDOObjectState. Deleted == kp. NDOObjectState, "2. Wrong state") ;
329 ············pm.Abort();
330 Assert. That( NDOObjectState. Persistent == r. NDOObjectState, "1. Wrong state") ;
331 Assert. That( NDOObjectState. Persistent == kp. NDOObjectState, "2. Wrong state") ;
 
332 ········}
333
334 ········[Test]
335 public void TestAddRemoveSave( ) {
336 var pm = PmFactory. NewPersistenceManager( ) ;
337 pm. MakePersistent( r) ;
 
 
338 ············pm.Save();
339 r. AddKostenpunkt( kp) ;
340 r. Löschen( kp) ;
341 Assert. That( NDOObjectState. Transient == kp. NDOObjectState, "1. Wrong state") ;
342 ············pm.Save();
343 Assert. That( NDOObjectState. Transient == kp. NDOObjectState, "2. Wrong state") ;
 
344 ········}
345
346 ········[Test]
347 public void TestAddRemoveAbort( ) {
348 var pm = PmFactory. NewPersistenceManager( ) ;
349 pm. MakePersistent( r) ;
 
 
350 ············pm.Save();
351 r. AddKostenpunkt( kp) ;
352 r. Löschen( kp) ;
353 Assert. That( NDOObjectState. Transient == kp. NDOObjectState, "1. Wrong state") ;
354 ············pm.Abort();
355 Assert. That( NDOObjectState. Transient == kp. NDOObjectState, "2. Wrong state") ;
 
356 ········}
357
358 ········[Test]
359 public void TestClearRelatedObjectsSave( ) {
360 var pm = PmFactory. NewPersistenceManager( ) ;
361 for ( int i = 0; i < 10; i++) {
362 r. AddKostenpunkt( CreateBeleg( i*10+100) ) ;
 
 
 
363 ············}
364 pm. MakePersistent( r) ;
365 ············pm.Save();
366 ············IList rr = r.Kostenpunkte.ToList();
367 ············r.LöscheKostenpunkte();
368 Assert. That( 0 == r. Kostenpunkte. Count, "1. Wrong number of objects") ;
369 for( int i = 0; i < 10; i++) {
370 Assert. That( NDOObjectState. Deleted == ( ( Kostenpunkt) rr[i]) . NDOObjectState, "2. Wrong state") ;
 
371 ············}
372 ············pm.Save();
373 Assert. That( 0 == r. Kostenpunkte. Count, "3. Wrong number of objects") ;
374 for( int i = 0; i < 10; i++) {
375 Assert. That( NDOObjectState. Transient == ( ( Kostenpunkt) rr[i]) . NDOObjectState, "4. Wrong state") ;
 
 
376 ············}
377 ········}
378
379 ········[Test]
380 public void TestClearRelatedObjectsAbort( ) {
 
381 ············for(int i = 0; i < 10; i++) {
382 ················r.AddKostenpunkt(CreateBeleg(i*10+100));
383 ············}
384 var pm = PmFactory. NewPersistenceManager( ) ;
385 pm. MakePersistent( r) ;
 
386 ············pm.Save();
387 ············IList rr = r.Kostenpunkte.ToList();
388 ············r.LöscheKostenpunkte();
389 Assert. That( 0 == r. Kostenpunkte. Count, "1. Wrong number of objects") ;
390 for( int i = 0; i < 10; i++) {
391 Assert. That( NDOObjectState. Deleted == ( ( Kostenpunkt) rr[i]) . NDOObjectState, "2. Wrong state") ;
 
392 ············}
393 ············pm.Abort();
394 Assert. That( 10 == r. Kostenpunkte. Count, "3. Wrong number of objects") ;
395 for( int i = 0; i < 10; i++) {
396 Assert. That( NDOObjectState. Persistent == ( ( Kostenpunkt) rr[i]) . NDOObjectState, "4. Wrong state") ;
 
 
397 ············}
398 ········}
399
400 ········[Test]
401 public void TestAssignRelatedObjectsNullSave( ) {
402 for( int i = 0; i < 3; i++) {
403 r. AddKostenpunkt( CreateBeleg( i*10+100) ) ;
 
 
404 ············}
405 var pm = PmFactory. NewPersistenceManager( ) ;
406 pm. MakePersistent( r) ;
 
407 ············pm.Save();
408 ············IList rr = r.Kostenpunkte.ToList();
409 ············r.ErsetzeKostenpunkte();
410 Assert. That( r. Kostenpunkte == null, "No objects should be there") ;
411 for( int i = 0; i < 3; i++) {
412 Assert. That( NDOObjectState. Deleted == ( ( Kostenpunkt) rr[i]) . NDOObjectState, "2. Wrong state") ;
 
413 ············}
414 ············pm.Save();
415 Assert. That( r. Kostenpunkte == null, "No objects should be there") ;
416 for( int i = 0; i < 3; i++) {
417 Assert. That( NDOObjectState. Transient == ( ( Kostenpunkt) rr[i]) . NDOObjectState, "4. Wrong state") ;
 
 
418 ············}
419 ········}
420
421 ········[Test]
422 public void TestAssignRelatedObjectsNullAbort( ) {
423 for( int i = 0; i < 3; i++) {
424 r. AddKostenpunkt( CreateBeleg( i*10+100) ) ;
 
 
425 ············}
426 var pm = PmFactory. NewPersistenceManager( ) ;
427 pm. MakePersistent( r) ;
 
428 ············pm.Save();
429 ············IList rr = r.Kostenpunkte.ToList();
430 ············r.ErsetzeKostenpunkte();
431 Assert. That( r. Kostenpunkte == null, "No objects should be there") ;
432 for( int i = 0; i < 3; i++) {
433 Assert. That( NDOObjectState. Deleted == ( ( Kostenpunkt) rr[i]) . NDOObjectState, "2. Wrong state") ;
 
434 ············}
435 ············pm.Abort();
436 Assert. That( 3 == r. Kostenpunkte. Count, "3. Wrong number of objects") ;
437 for( int i = 0; i < 3; i++) {
438 Assert. That( NDOObjectState. Persistent == ( ( Kostenpunkt) rr[i]) . NDOObjectState, "4. Wrong state") ;
 
 
439 ············}
440 ········}
441
442 ········[Test]
443 public void TestAssignRelatedObjectsSave( ) {
444 for( int i = 0; i < 3; i++) {
445 r. AddKostenpunkt( CreateBeleg( i*10+100) ) ;
 
 
446 ············}
447 var pm = PmFactory. NewPersistenceManager( ) ;
448 pm. MakePersistent( r) ;
 
449 ············pm.Save();
450 ············List<Kostenpunkt> neueKostenpunkte = new List<Kostenpunkt>();
451 ············Kostenpunkt nr = CreateBeleg(50);
452 neueKostenpunkte. Add( nr) ;
453
454 ············IList rr = r.Kostenpunkte.ToList();
455 r. ErsetzeKostenpunkte( neueKostenpunkte) ;
456 Assert. That( 1 == r. Kostenpunkte. Count, "1. Wrong number of objects") ;
457 for( int i = 0; i < 3; i++) {
458 Assert. That( NDOObjectState. Deleted == ( ( Kostenpunkt) rr[i]) . NDOObjectState, "2. Wrong state") ;
 
459 ············}
460 Assert. That( NDOObjectState. Created == nr. NDOObjectState, "3. Wrong state") ;
461
462 ············pm.Save();
463 Assert. That( 1 == r. Kostenpunkte. Count, "4. Wrong number of objects") ;
464 for( int i = 0; i < 3; i++) {
465 Assert. That( NDOObjectState. Transient == ( ( Kostenpunkt) rr[i]) . NDOObjectState, "5. Wrong state") ;
 
 
 
466 ············}
467 ············Assert.That(NDOObjectState.Persistent ==··nr.NDOObjectState, "6. Wrong state");
468 ········}
469
470 ········[Test]
471 public void TestAssignRelatedObjectsAbort( ) {
472 for( int i = 0; i < 3; i++) {
473 r. AddKostenpunkt( CreateBeleg( i*10+100) ) ;
 
 
474 ············}
475 var pm = PmFactory. NewPersistenceManager( ) ;
476 pm. MakePersistent( r) ;
 
477 ············pm.Save();
478 ············List<Kostenpunkt> neueKostenpunkte = new List<Kostenpunkt>();
479 ············Kostenpunkt nr = CreateBeleg(200);
480 neueKostenpunkte. Add( nr) ;
481
482 ············IList rr = r.Kostenpunkte.ToList();
483 r. ErsetzeKostenpunkte( neueKostenpunkte) ;
484 Assert. That( 1 == r. Kostenpunkte. Count, "1. Wrong number of objects") ;
485 for( int i = 0; i < 3; i++) {
486 Assert. That( NDOObjectState. Deleted == ( ( Kostenpunkt) rr[i]) . NDOObjectState, "2. Wrong state") ;
 
487 ············}
488 Assert. That( NDOObjectState. Created == nr. NDOObjectState, "3. Wrong state") ;
489
490 ············pm.Abort();
491 Assert. That( 3 == r. Kostenpunkte. Count, "4. Wrong number of objects") ;
492 for( int i = 0; i < 3; i++) {
493 Assert. That( NDOObjectState. Persistent == ( ( Kostenpunkt) rr[i]) . NDOObjectState, "5. Wrong state") ;
 
 
 
494 ············}
495 ············Assert.That(NDOObjectState.Transient ==··nr.NDOObjectState, "6. Wrong state");
496 ········}
497
498
499 ········[Test]
500 public void TestHollow( ) {
501 r. AddKostenpunkt( kp) ;
502 var pm = PmFactory. NewPersistenceManager( ) ;
503 pm. MakePersistent( r) ;
 
 
504 ············pm.Save();
505 pm. MakeHollow( r) ;
506 Assert. That( NDOObjectState. Hollow == r. NDOObjectState, "1: Reise should be hollow") ;
507 Assert. That( NDOObjectState. Persistent == kp. NDOObjectState, "1: Kostenpunkt should be persistent") ;
508 ············var kostenpunkte = r.Kostenpunkte;
509
510 pm. MakeHollow( r, true) ;
511 Assert. That( NDOObjectState. Hollow == r. NDOObjectState, "2: Reise should be hollow") ;
512 Assert. That( NDOObjectState. Hollow == kp. NDOObjectState, "2: Kostenpunkt should be hollow") ;
513
514 ············kostenpunkte = r.Kostenpunkte;
515 Assert. That( NDOObjectState. Persistent == r. NDOObjectState, "3: Reise should be persistent") ;
516 Assert. That( NDOObjectState. Hollow == kp. NDOObjectState, "3: Kostenpunkt should be hollow") ;
517 Assert. That( 200 == kp. Kosten, "3: Kostenpunkt should have correct Kosten") ;
518 Assert. That( NDOObjectState. Persistent == kp. NDOObjectState, "4: Kostenpunkt should be persistent") ;
 
519 ········}
520
521 ········[Test]
522 public void TestMakeAllHollow( ) {
523 r. AddKostenpunkt( kp) ;
524 var pm = PmFactory. NewPersistenceManager( ) ;
525 pm. MakePersistent( r) ;
 
 
526 ············pm.Save();
527 ············pm.MakeAllHollow();
528 Assert. That( NDOObjectState. Hollow == r. NDOObjectState, "1: Reise should be hollow") ;
529 Assert. That( NDOObjectState. Hollow == kp. NDOObjectState, "1: Kostenpunkt should be hollow") ;
 
530 ········}
 
531
532 ········[Test]
533 public void TestMakeAllHollowUnsaved( ) {
534 var pm = PmFactory. NewPersistenceManager( ) ;
535 r. AddKostenpunkt( kp) ;
536 pm. MakePersistent( r) ;
 
 
537 ············pm.MakeAllHollow();··// before save, objects cannot be made hollow. => in locked objects
538 Assert. That( NDOObjectState. Created == r. NDOObjectState, "1: Reise should be created") ;
539 Assert. That( NDOObjectState. Created == kp. NDOObjectState, "1: Kostenpunkt should be created") ;
 
540 ········}
541
542 ········[Test]
543 public void TestLoadRelatedObjects( ) {
544 for( int i = 0; i < 10; i++) {
545 r. AddKostenpunkt( CreateBeleg( i*10+100) ) ;
 
 
546 ············}
547 var pm = PmFactory. NewPersistenceManager( ) ;
548 pm. MakePersistent( r) ;
 
549 ············pm.Save();
550 pm. MakeHollow( r, true) ;
551
552 ············var kpunkte = r.Kostenpunkte.ToList();
553 Assert. That( 10 == kpunkte. Count, "Array size should be 10") ;
554
555 for( int i = 0; i < 10; i++) {
 
556 ················Kostenpunkt rr = (Kostenpunkt)kpunkte[i];
557 Assert. That( NDOObjectState. Hollow == rr. NDOObjectState, "1: Kostenpunkt should be hollow") ;
558 #if !ORACLE && !MYSQL && !FIREBIRD
559 Assert. That( i*10+100 == rr. Kosten, "2: Kostenpunkt should be in right order") ;
560 #endif
561 ············}
 
562
563
564 ············pm.MakeAllHollow();
565 ············pm.UnloadCache();
566 ············var kpunkte2 = r.Kostenpunkte.ToList();
567 for( int i = 0; i < 10; i++) {
 
568 ················Kostenpunkt r1 = (Kostenpunkt)kpunkte[i];
569 ················Kostenpunkt r2 = (Kostenpunkt)kpunkte2[i];
570 #if !ORACLE && !MYSQL && !FIREBIRD
571 Assert. That( i*10+100 == r1. Kosten, "3: Kostenpunkt should be in right order") ;
572 #endif
573 Assert. That( r1 != r2, "Objects should be different") ;
574 ············}
575 ········}
 
576
577 ········[Test]
578 public void TestLoadRelatedObjectsSave( ) {
579 var pm = PmFactory. NewPersistenceManager( ) ;
580 pm. MakePersistent( r) ;
 
 
581 ············pm.Save();
582 for( int i = 0; i < 10; i++) {
583 r. AddKostenpunkt( CreateBeleg( i*10+100) ) ;
 
584 ············}
585 ············pm.Save();
586 pm. MakeHollow( r, true) ;
587
588 ············IList reisen = r.Kostenpunkte.ToList();
589
590 for( int i = 0; i < 10; i++) {
 
591 ················Kostenpunkt rr = (Kostenpunkt)reisen[i];
592 Assert. That( NDOObjectState. Hollow == rr. NDOObjectState, "1: Kostenpunkt should be hollow") ;
593 #if !ORACLE && !MYSQL && !FIREBIRD
594 Assert. That( i*10+100 == rr. Kosten, "2: Kostenpunkt should be in right order") ;
595 #endif
596 ············}
597
598
599 ············pm.MakeAllHollow();
600 ············pm.UnloadCache();
601 ············IList reisen2 = r.Kostenpunkte.ToList();
602 for( int i = 0; i < 10; i++) {
 
603 ················Kostenpunkt r1 = (Kostenpunkt)reisen[i];
604 ················Kostenpunkt r2 = (Kostenpunkt)reisen2[i];
605 #if !ORACLE && !MYSQL && !FIREBIRD
606 Assert. That( i*10+100 == r1. Kosten, "3: Kostenpunkt should be in right order") ;
607 #endif
608 Assert. That( r1 != r2, "Objects should be different") ;
 
609 ············}
610 ········}
611
612 ········[Test]
613 public void TestExtentRelatedObjects( ) {
614 r. AddKostenpunkt( kp) ;
615 var pm = PmFactory. NewPersistenceManager( ) ;
616 pm. MakePersistent( r) ;
 
 
617 ············pm.Save();
618 Assert. That( NDOObjectState. Persistent == r. NDOObjectState, "0: Reise should be persistent") ;
619 ············IList liste = pm.GetClassExtent(typeof(Reise));
620 r = ( Reise) liste[0];
621 Assert. That( 1 == liste. Count, "1: Number of Reise objects is wrong") ;
622 Assert. That( NDOObjectState. Persistent == r. NDOObjectState, "1: Reise should be persistent") ;
623 Assert. That( r. Kostenpunkte != null, "2. Relation is missing") ;
624 Assert. That( 1 == r. Kostenpunkte. Count, "3. Wrong number of objects") ;
625 Assert. That( NDOObjectState. Persistent == ( ( Kostenpunkt) r. Kostenpunkte[0]) . NDOObjectState, "4. : Kostenpunkt should be hollow") ;
626
627 ············pm.UnloadCache();
628 liste = pm. GetClassExtent( typeof( Reise) ) ;
629 r = ( Reise) liste[0];
630 Assert. That( NDOObjectState. Hollow == r. NDOObjectState, "5: Reise should be hollow") ;
631 Assert. That( r. Kostenpunkte != null, "6. Relation is missing") ;
632 Assert. That( 1 == r. Kostenpunkte. Count, "7. Wrong number of objects") ;
633 Assert. That( NDOObjectState. Hollow == ( ( Kostenpunkt) r. Kostenpunkte[0]) . NDOObjectState, "8. : Kostenpunkt should be hollow") ;
634
635 ············pm.UnloadCache();
636 liste = pm. GetClassExtent( typeof( Reise) , false) ;
637 r = ( Reise) liste[0];
638 Assert. That( NDOObjectState. Persistent == r. NDOObjectState, "9: Reise should be persistent") ;
639 Assert. That( r. Kostenpunkte != null, "10. Relation is missing") ;
640 Assert. That( 1 == r. Kostenpunkte. Count, "11. Wrong number of objects") ;
641 Assert. That( NDOObjectState. Hollow == ( ( Kostenpunkt) r. Kostenpunkte[0]) . NDOObjectState, "12. : Kostenpunkt should be hollow") ;
 
642 ········}
643
644 ········[Test]
645 ········public void TestJoinQuery()
 
 
646 ········{
647 ············var pm = PmFactory.NewPersistenceManager();
648
649 ············Person p = new Person();
650 ············p.FirstName = "Mirko";
651 ············p.LastName = "Matytschak";
652 ············p.Moniker = "Hallo";
653 ············Adresse a1 = new Adresse();
654 ············a1.Lkz = "D";
655 ············a1.Plz = "83646";
656 ············a1.Straße = "Nockhergasse 7";
657 ············a1.Ort = "Bad Tölz";
658
659 ············Adresse a2 = new Adresse();
660 ············a2.Ort = "Mönchen";
661 ············a2.Plz = "80331";
662 ············a2.Straße = "Isartorplatz 5";
663 ············a2.Lkz = "D";
664
665 ············Institution i = new Institution();
666 ············i.FirstName = "Schnulli";
667 ············i.LastName = "Wauwau";
668 ············i.Hausmeister = "Möller";
669
670 pm. MakePersistent( a1) ;
671 pm. MakePersistent( a2) ;
672 pm. MakePersistent( p) ;
673 pm. MakePersistent( i) ;
674 i. AddAdresse( a1) ;
675 p. AddAdresse( a1) ;
676 p. AddAdresse( a2) ;
677 ············pm.Save();
678 ············pm.UnloadCache();
679
680 ············IQuery q = new NDOQuery<Contact>(pm, $"addresses.plz = '{a2.Plz}'");
681 ············IList l = q.Execute();
682 Assert. That( 1 == l. Count, "Wrong number of contacts") ;
683 ········}
 
684
685 ········[Test]
686 ········public void TestPolymorphicCondition()
687 ········{
688 r. AddKostenpunkt( kp) ;
689 var pm = PmFactory. NewPersistenceManager( ) ;
690 pm. MakePersistent( r) ;
 
691 ············pm.Save();
692
693 ············pm.UnloadCache();
694 ············NDOQuery<Reise> q = new NDOQuery<Reise>(pm, "belege.datum" + " = " + "{0}");
695 q. Parameters. Add( DateTime. Now. Date) ;
696 r = ( Reise) q. ExecuteSingle( true) ;
697 Assert. That( r != null, "Reise not found") ;
698 Assert. That( r. Kostenpunkte. Count > 0, "No Beleg" ) ;
699 Assert. That( r. Kostenpunkte[0] != null, "Beleg not found" ) ;
 
700 ········}
701
702 ········[Test]
703 ········public void TestSortedQueryAsc()
704 ········{
705 var pm = PmFactory. NewPersistenceManager( ) ;
 
706
707 r. AddKostenpunkt( kp) ;
708 ············DateTime yesterday = DateTime.Today - new TimeSpan(1, 0, 0, 0);
709 ············kp.Datum = yesterday;
710 r. AddKostenpunkt( kp = CreatePkw( ) ) ;
711 ············kp.Datum = DateTime.Today;
712 pm. MakePersistent( r) ;
713 ············pm.Save();
714
715 ············pm.UnloadCache();
716 ············IQuery q = new NDOQuery<Kostenpunkt>(pm);
717 q. Orderings. Add( new AscendingOrder( "datum") ) ;
718 ············IList l = q.Execute();
719 Assert. That( 2 == l. Count, "Count wrong") ;
720 Assert. That( yesterday == ( ( Kostenpunkt) l[0]) . Datum, "Order wrong") ;
721 Assert. That( DateTime. Today == ( ( Kostenpunkt) l[1]) . Datum, "Wrong object") ;
 
722 ········}
723
724 ········[Test]
725 ········public void TestSortedQueryDesc()
 
 
726 ········{
727 var pm = PmFactory. NewPersistenceManager( ) ;
728
729 ············r.AddKostenpunkt(kp);
730 ············DateTime yesterday = DateTime.Today - new TimeSpan(1, 0, 0, 0);
731 ············kp.Datum = yesterday;
732 r. AddKostenpunkt( kp = CreatePkw( ) ) ;
733 ············kp.Datum = DateTime.Today;
734 pm. MakePersistent( r) ;
735 ············pm.Save();
736
737 ············pm.UnloadCache();
738 ············IQuery q = new NDOQuery<Kostenpunkt>(pm);
739 q. Orderings. Add( new DescendingOrder( "datum") ) ;
740 ············IList l = q.Execute();
741 //pm. VerboseMode = false;
742 Assert. That( 2 == l. Count, "Count wrong") ;
743 Assert. That( DateTime. Today == ( ( Kostenpunkt) l[0]) . Datum, "Order wrong") ;
744 Assert. That( yesterday == ( ( Kostenpunkt) l[1]) . Datum, "Wrong object") ;
 
745 ········}
746
747 ········[Test]
748 ········public void TestSortedQueryAscOneNull()
 
 
749 ········{
750 ············var pm = PmFactory.NewPersistenceManager();
751
752 r. AddKostenpunkt( kp) ;
753 ············kp.Datum = DateTime.MinValue;··// DbNull
754 r. AddKostenpunkt( kp = CreatePkw( ) ) ;
755 ············kp.Datum = DateTime.Today;
756 pm. MakePersistent( r) ;
757 ············pm.Save();
758
759 ············pm.UnloadCache();
760 ············IQuery q = new NDOQuery<Kostenpunkt>(pm);
761 q. Orderings. Add( new AscendingOrder( "datum") ) ;
762 ············IList l = q.Execute();
763 ············//pm.VerboseMode = false;
764 Assert. That( 2 == l. Count, "Count wrong") ;
765 Assert. That( DateTime. MinValue == ( ( Kostenpunkt) l[0]) . Datum, "Order wrong") ;
766 Assert. That( DateTime. Today == ( ( Kostenpunkt) l[1]) . Datum, "Wrong object") ;
 
767 ········}
768
769 ········[Test]
770 ········public void TestSortedQueryBothNull()
771 ········{
772 var pm = PmFactory. NewPersistenceManager( ) ;
 
773
774 r. AddKostenpunkt( kp) ;
775 ············kp.Datum = DateTime.MinValue;··// DbNull
776 r. AddKostenpunkt( kp = CreatePkw( ) ) ;
777 ············kp.Datum = DateTime.MinValue;··// DbNull
778 pm. MakePersistent( r) ;
779 ············pm.Save();
780
781 ············pm.UnloadCache();
782 ············IQuery q = new NDOQuery<Kostenpunkt>(pm);
783 q. Orderings. Add( new AscendingOrder( "datum") ) ;
784 ············IList l = q.Execute();
785 ············//pm.VerboseMode = false;
786 Assert. That( 2 == l. Count, "Count wrong") ;
787 Assert. That( DateTime. MinValue == ( ( Kostenpunkt) l[0]) . Datum, "Wrong Date #1") ;
788 Assert. That( DateTime. MinValue == ( ( Kostenpunkt) l[1]) . Datum, "Wrong Date #2") ;
 
789 ········}
790
791 ········[Test]
792 ········public void TestSortedQueryDescOneNull()
 
 
793 ········{
794 var pm = PmFactory. NewPersistenceManager( ) ;
795 ············r.AddKostenpunkt(kp);
796 ············kp.Datum = DateTime.MinValue;
797 r. AddKostenpunkt( kp = CreatePkw( ) ) ;
798 ············kp.Datum = DateTime.Today;
799 pm. MakePersistent( r) ;
800 ············pm.Save();
801
802 ············pm.UnloadCache();
803 ············IQuery q = new NDOQuery<Kostenpunkt>(pm);
804 q. Orderings. Add( new DescendingOrder( "datum") ) ;
805 ············IList l = q.Execute();
806 ············//pm.VerboseMode = false;
807 Assert. That( 2 == l. Count, "Count wrong") ;
808 Assert. That( DateTime. Today == ( ( Kostenpunkt) l[0]) . Datum, "Order wrong") ;
809 Assert. That( DateTime. MinValue == ( ( Kostenpunkt) l[1]) . Datum, "Wrong object") ;
 
810 ········}
811
812
813 ········[Test]
814 ········public void TestQueryForSingleObject()
815 ········{
816 var pm = PmFactory. NewPersistenceManager( ) ;
 
817 ············Kostenpunkt kp2 = CreatePkw(100);
818 r. AddKostenpunkt( kp) ;
819 r. AddKostenpunkt( kp2) ;
820 pm. MakePersistent( r) ;
821 ············pm.Save();
822 ············pm.UnloadCache();
823 ············NDOQuery<Reise> q = new NDOQuery<Reise>(pm, "belege.datum" + " = " + "{0}");
824 q. Parameters. Add( DateTime. Now. Date) ;
825 ············IList l = q.Execute();
826 Assert. That( 1 == l. Count, "Count wrong") ;
 
827 ········}
828
829
830 ········[Test]
831 ········public void TestPolyDelete()
832 ········{
833 var pm = PmFactory. NewPersistenceManager( ) ;
 
834 ············Kostenpunkt kp2 = CreatePkw(100);
835 r. AddKostenpunkt( kp) ;
836 r. AddKostenpunkt( kp2) ;
837 pm. MakePersistent( r) ;
838 ············pm.Save();
839 ············pm.UnloadCache();
840 ············NDOQuery<Reise> q = new NDOQuery<Reise>(pm, "belege.datum" + " = " + "{0}");
841 q. Parameters. Add( DateTime. Now. Date) ;
842 ············IList l = q.Execute();
843 Assert. That( 1 == l. Count, "Count wrong") ;
844 ············r = (Reise) l[0];
845 pm. Delete( r) ;
846 ············pm.Save();
847 ········}
 
848
849
850 ········[Test]
851 ········public void RelationTest()
 
 
852 ········{
853 ············var pm = PmFactory.NewPersistenceManager();
854 ············NDOMapping mapping = pm.NDOMapping;
855 ············Class reiseClass = mapping.FindClass(typeof(Reise));
856 ············Class pkwClass = mapping.FindClass(typeof(PKWFahrt));
857 Assert. That( reiseClass != null, "Mapping for Reise not found") ;
858 Assert. That( pkwClass != null, "Mapping for pkw not found") ;
859 ············Relation r1 = reiseClass.FindRelation("belege");
860 Assert. That( r1 != null, "Relation not found #1") ;
861 Assert. That( r1. ForeignRelation != null, "ForeignRelation of Reise not found") ;
862 ············Relation r2 = pkwClass.FindRelation("reise");
863 Assert. That( r2 != null, "Relation not found #2") ;
864 Assert. That( r2. ForeignRelation != null, "ForeignRelation of PKWFahrt not found") ;
865 Assert. That( r1 == r2. ForeignRelation, "Back relation wrong") ;
866 //············Debug.WriteLine(r1.Parent.FullName + "->" + r1.ReferencedTypeName);
867 //············Debug.WriteLine(r1.ForeignRelation.Parent.FullName + "->" + r1.ForeignRelation.ReferencedTypeName);
868 //············Debug.WriteLine(r2.Parent.FullName + "->" + r2.ReferencedTypeName);
869 //············Debug.WriteLine(r2.ForeignRelation.Parent.FullName + "->" + r2.ForeignRelation.ReferencedTypeName);
 
870 ········}
871
872
873 ········private Kostenpunkt CreateBeleg(double betrag)
874 ········{
875 ············return new Beleg("Taxi", betrag);
876 ········}
877
878 ········private Kostenpunkt CreateBeleg() {
879 ············return new Beleg("Flug", 200);
880 ········}
881
882 ········private Kostenpunkt CreatePkw() {
883 ············return CreatePkw(100);
884 ········}
885
886 ········private Kostenpunkt CreatePkw(double km) {
887 ············return new PKWFahrt(km);
888 ········}
889
890 ········private Reise CreateReise(string zweck) {
891 ············Reise r = new Reise();
892 ············r.Zweck = zweck;
893 ············return r;
894 ········}
895 ····}
896 }
897
New Commit (60aa080)
1 //
2 // Copyright ( c) 2002-2025 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.Diagnostics;
25 using System.Collections;
26 using NUnit.Framework;
27 using NDO;
28 using NDO.Mapping;
29 using Reisekosten;
30 using Reisekosten.Personal;
31 using PureBusinessClasses;
32 using NDO.Query;
33 using System.Linq;
34 using System.Collections.Generic;
35
36 namespace NdoUnitTests {
37 ····/// <summary>
38 ····/// Polymorphic tests.
39 ····/// </summary>
40 ····[TestFixture]
41 ····public class PolymorphicWTable : NDOTest
42 ····{
43 ········public PolymorphicWTable() {
44 ········}
45
46 ········private Reise r;
47 ········private Kostenpunkt kp;
48 ········private ICollection onSavingCollection = null;
49
50 ········[SetUp]
51 ········public void Setup() {
52 ············r = CreateReise("ADC");
53 ············kp = CreateBeleg();
54 ········}
55
56 ········[TearDown]
57 ········public void TearDown() {
58 using ( var pm = PmFactory. NewPersistenceManager( ) )
59 ············{
60 ················pm.TransactionMode = TransactionMode.None;
61
62 ················//pm.UnloadCache();
63 ················IList reiseliste = pm.GetClassExtent(typeof(Reise), true);
64 pm. Delete( reiseliste ) ;
65 ················pm.Save();
66 ················pm.UnloadCache();
67 ················IQuery q;
68 ················IList liste;
69
70 ················// We can't delete orphan Beleg object with NDO, so use direct Sql statements
71 ················using (var handler = pm.GetSqlPassThroughHandler())
72 ················{
73 ····················var sql = "DELETE FROM " + pm.NDOMapping.FindClass( typeof( Beleg ) ).TableName;
74 ····················handler.Execute( sql );
75 ················}
76
77 q = new NDOQuery<Contact>( pm ) ;
78 ················liste = q.Execute();
79 pm. Delete( liste ) ;
80 ················pm.Save();
81 q = new NDOQuery<Adresse>( pm ) ;
82 ················liste = q.Execute();
83 pm. Delete( liste ) ;
84 ················pm.Save();
85 }
86 ········}
87
88 ········[Test]
89 public void TestCreateObjects( )
90 {
91 using ( var pm = PmFactory. NewPersistenceManager( ) )
92 {
93 pm. MakePersistent( r ) ;
94 ················r.AddKostenpunkt( kp );
95 ················Assert.That( NDOObjectState.Created == kp.NDOObjectState, "Beleg should be Created: " );
96 ············}
97 ········}
98
99
100 ········[Test]
101 public void TestCreateObjects2( )
102 {
103 using ( var pm = PmFactory. NewPersistenceManager( ) )
104 {
105 r. AddKostenpunkt( kp ) ;
106 ················pm.MakePersistent( r );
107 ················Assert.That( NDOObjectState.Created == kp.NDOObjectState, "Beleg should be Created: " );
108 ············}
109 ········}
110
111 ········[Test]
112 public void TestCreateObjectsSave( )
113 {
114 using ( var pm = PmFactory. NewPersistenceManager( ) )
115 {
116 ················r.AddKostenpunkt( kp );
117 ················pm.MakePersistent( r );
118 ················pm.Save();
119
120 ················pm.UnloadCache();
121 r = ( Reise) pm. FindObject( r. NDOObjectId ) ;
122 Assert. That( r != null, "Reise not found" ) ;
123 Assert. That( 1 == r. Kostenpunkte. Count ) ;
124 Assert. That( r. Kostenpunkte[0] != null, "Beleg not found" ) ;
125 ············}
126 ········}
127
128 ········[Test]
129 public void TestCreateManyObjectsSave( )
130 {
131 using ( var pm = PmFactory. NewPersistenceManager( ) )
132 {
133 ················r.AddKostenpunkt( kp );
134 ················pm.MakePersistent( r );
135 ················pm.Save();
136
137 r. AddKostenpunkt( CreateBeleg( 50 ) ) ;
138 r. AddKostenpunkt( CreateBeleg( 50 ) ) ;
139 ················pm.Save();
140 ················pm.UnloadCache();
141 r = ( Reise) pm. FindObject( r. NDOObjectId ) ;
142 Assert. That( r != null, "Reise not found" ) ;
143 Assert. That( 3 == r. Kostenpunkte. Count, "Anzahl Belege: " ) ;
144 Assert. That( r. Kostenpunkte[0] != null, "Beleg not found" ) ;
145 Assert. That( 300 == r. Gesamtkosten, "Gesamtkosten: " ) ;
146 ············}
147 ········}
148
149 ········[Test]
150 public void TestCreatePolymorphicObjectsSave( )
151 {
152 using ( var pm = PmFactory. NewPersistenceManager( ) )
153 {
154 ················r.AddKostenpunkt( kp );
155 ················pm.MakePersistent( r );
156 ················pm.Save();
157
158 r. AddKostenpunkt( CreatePkw( 100 ) ) ;
159 r. AddKostenpunkt( CreateBeleg( 50 ) ) ;
160 ················pm.Save();
161 ················pm.UnloadCache();
162 r = ( Reise) pm. FindObject( r. NDOObjectId ) ;
163 Assert. That( r != null, "Reise not found" ) ;
164 Assert. That( r. Kostenpunkte[0] != null, "Beleg not found" ) ;
165 Assert. That( 3 == r. Kostenpunkte. Count, "Anzahl Belege: " ) ;
166 Assert. That( 300 == r. Gesamtkosten, "Gesamtkosten: " ) ;
167 Assert. That( typeof( Beleg ) == r. Kostenpunkte[0]. GetType( ) , "Type" ) ;
168 Assert. That( typeof( PKWFahrt ) == r. Kostenpunkte[1]. GetType( ) , "Type" ) ;
169 Assert. That( typeof( Beleg ) == r. Kostenpunkte[2]. GetType( ) , "Type" ) ;
170 }
171 ········}
172
173 ········[Test]
174 ········public void TestPolymorphicQuery()
175 ········{
176 ············using (var pm = PmFactory.NewPersistenceManager())
177 ············{
178 r. AddKostenpunkt( kp ) ;
179 r. AddKostenpunkt( CreatePkw( 100 ) ) ;
180 r. AddKostenpunkt( CreateBeleg( 50 ) ) ;
181 pm. MakePersistent( r ) ;
 
 
182 ················pm.Save();
183 ················pm.UnloadCache();
184
185 ················IQuery q = new NDOQuery<Kostenpunkt>(pm, null);
186 ················IList l = q.Execute();
187 Assert. That( 3 == l. Count, "Anzahl Belege: " ) ;
188 ············}
189 ········}
190
191
192 ········[Test]
193 ········public void TestPolymorphicAggregateQuery()
194 ········{
195 ············using (var pm = PmFactory.NewPersistenceManager())
196 ············{
197 r. AddKostenpunkt( kp ) ;
198 r. AddKostenpunkt( CreatePkw( 100 ) ) ;
199 r. AddKostenpunkt( CreateBeleg( 50 ) ) ;
200 pm. MakePersistent( r ) ;
 
 
201 ················if (r.NDOObjectId.Id[0] is Int32)
202 ················{
203 ····················pm.Save();
204 ····················decimal sum = 0m;
205 foreach ( Kostenpunkt kp2 in r. Kostenpunkte)
206 ····················{
207 sum += ( Int32) kp2. NDOObjectId. Id[0];
208 ····················}
209
210 ····················IQuery q = new NDOQuery<Kostenpunkt>(pm, null);
211 ····················decimal newsum = (decimal)q.ExecuteAggregate("oid", AggregateType.Sum);
212 Assert. That( sum == newsum, "Summe stimmt nicht: " ) ;
213 ····················decimal newcount = (decimal)q.ExecuteAggregate("oid", AggregateType.Count);
214 Assert. That( 3 == newcount, "Summe stimmt nicht: " ) ;
215 ················}
216 ············}
217 ········}
218
219 ········[Test]
220 ········public void TestOnSavingEvent()
221 ········{
222 ············using (var pm = PmFactory.NewPersistenceManager())
223 ············{
224 r. AddKostenpunkt( kp ) ;
225 r. AddKostenpunkt( CreatePkw( 100 ) ) ;
226 r. AddKostenpunkt( CreateBeleg( 50 ) ) ;
227 pm. MakePersistent( r ) ;
228 pm. OnSavingEvent += new OnSavingHandler( this. OnSavingListener ) ;
 
 
229 ················pm.Save();
230 Assert. That( this. onSavingCollection != null, "onSavingCollection is null" ) ;
231 ············}
232 ········}
233
234 ········private void OnSavingListener(ICollection c)
235 ········{
236 ············this.onSavingCollection = c;
237 ········}
238
239
240
241 ········[Ignore("Future Feature")]
242 ········[Test]
243 ········public void TestPolymorphicQueryWithSql()
244 ········{
245 using ( var pm = PmFactory. NewPersistenceManager( ) )
246 {
247 r. AddKostenpunkt( kp ) ;
248 r. AddKostenpunkt( CreatePkw( 100 ) ) ;
249 r. AddKostenpunkt( CreateBeleg( 50 ) ) ;
250 ················pm.MakePersistent( r );
251 ················pm.Save();
252 ················pm.UnloadCache();
253
254 ················string sql = @"SELECT DISTINCT Reise.ID FROM Reise, relBelegKostenpunkt, PKWFahrt, Beleg WHERE ((relBelegKostenpunkt.IDReise = Reise.ID AND relBelegKostenpunkt.TCBeleg = 4) AND PKWFahrt.ID != 0 ) OR··((relBelegKostenpunkt.IDReise = Reise.ID AND relBelegKostenpunkt.TCBeleg = 3) AND Beleg.ID != 0)";
255 ················//string sql = "select distinct Reise.ID from Reise";
256 ················//string sql = "select * from Reise";
257
258 ················NDOQuery<Reise> q = new NDOQuery<Reise>(pm, sql, true, QueryLanguage.Sql);
259 ················//System.Diagnostics.Debug.WriteLine(q.GeneratedQuery);
260
261 ················IList l = q.Execute();
262 Assert. That( 1 == l. Count, "Anzahl Reisen: " ) ;
263 ············}
264 ········}
265
266 ········
267 ········[Test]
268 ········public void TestAddObjectSave() {
269 using ( var pm = PmFactory. NewPersistenceManager( ) )
270 {
271 ················pm.MakePersistent( r );
272 ················pm.Save();
273 r. AddKostenpunkt( kp ) ;
274 Assert. That( NDOObjectState. Created == kp. NDOObjectState, "1. Wrong state" ) ;
275 ················pm.Save();
276 r = ( Reise) pm. FindObject( r. NDOObjectId ) ;
277 kp = ( Kostenpunkt) pm. FindObject( kp. NDOObjectId ) ;
278 Assert. That( r != null, "1. Reise not found" ) ;
279 Assert. That( kp != null, "2. Beleg not found" ) ;
280 Assert. That( NDOObjectState. Persistent == kp. NDOObjectState, "3. Wrong state" ) ;
281 Assert. That( DateTime. Now. Date == kp. Datum, "Wrong data" ) ;
282 ············}
283 ········}
284 ············
285 ········[Test]
286 public void TestAddObjectAbort( )
287 {
288 using ( var pm = PmFactory. NewPersistenceManager( ) )
289 ············{
290 ················pm.MakePersistent( r );
291 ················pm.Save();
292 r. AddKostenpunkt( kp ) ;
293 Assert. That( NDOObjectState. Created == kp. NDOObjectState, "1. Wrong state" ) ;
294 Assert. That( 1 == r. Kostenpunkte. Count, "1. Wrong number of objects" ) ;
295 ················pm.Abort();
296 Assert. That( NDOObjectState. Transient == kp. NDOObjectState, "2. Wrong state" ) ;
297 Assert. That( 0 == r. Kostenpunkte. Count, "2. Wrong number of objects" ) ;
298 ············}
299 ········}
300
301 ········[Test]
302 public void TestRemoveObjectSave( )
303 {
304 using ( var pm = PmFactory. NewPersistenceManager( ) )
305 {
306 ················pm.MakePersistent( r );
307 ················r.AddKostenpunkt( kp );
308 ················pm.Save();
309 Assert. That( 1 == r. Kostenpunkte. Count, "1. Wrong number of objects" ) ;
310 r. Löschen( kp ) ;
311 Assert. That( NDOObjectState. Deleted == kp. NDOObjectState, "1. Wrong state" ) ;
312 Assert. That( 0 == r. Kostenpunkte. Count, "2. Wrong number of objects" ) ;
313 ················pm.Save();
314 Assert. That( 0 == r. Kostenpunkte. Count, "3. Wrong number of objects" ) ;
315 Assert. That( NDOObjectState. Transient == kp. NDOObjectState, "2. Wrong state" ) ;
316 ············}
317 ········}
318 ············
319 ········[Test]
320 public void TestRemoveObjectAbort( )
321 {
322 using ( var pm = PmFactory. NewPersistenceManager( ) )
323 {
324 ················pm.MakePersistent( r );
325 ················r.AddKostenpunkt( kp );
326 ················pm.Save();
327 Assert. That( 1 == r. Kostenpunkte. Count, "1. Wrong number of objects" ) ;
328 r. Löschen( kp ) ;
329 Assert. That( NDOObjectState. Deleted == kp. NDOObjectState, "1. Wrong state" ) ;
330 Assert. That( 0 == r. Kostenpunkte. Count, "2. Wrong number of objects" ) ;
331 ················pm.Abort();
332 Assert. That( 1 == r. Kostenpunkte. Count, "3. Wrong number of objects" ) ;
333 Assert. That( NDOObjectState. Persistent == kp. NDOObjectState, "2. Wrong state" ) ;
334 ············}
335 ········}
336
337 ········[Test]
338 public void TestDeleteSave( )
339 {
340 using ( var pm = PmFactory. NewPersistenceManager( ) )
341 {
342 ················pm.MakePersistent( r );
343 ················r.AddKostenpunkt( kp );
344 ················pm.Save();
345 pm. Delete( r ) ;
346 Assert. That( NDOObjectState. Deleted == r. NDOObjectState, "1. Wrong state" ) ;
347 Assert. That( NDOObjectState. Deleted == kp. NDOObjectState, "2. Wrong state" ) ;
348 ················pm.Save();
349 Assert. That( NDOObjectState. Transient == r. NDOObjectState, "1. Wrong state" ) ;
350 Assert. That( NDOObjectState. Transient == kp. NDOObjectState, "2. Wrong state" ) ;
351 ············}
352 ········}
353
354
355
356 ········[Test]
357 public void TestDeleteAbort( )
358 {
359 using ( var pm = PmFactory. NewPersistenceManager( ) )
360 {
361 ················pm.MakePersistent( r );
362 ················r.AddKostenpunkt( kp );
363 ················pm.Save();
364 pm. Delete( r ) ;
365 Assert. That( NDOObjectState. Deleted == r. NDOObjectState, "1. Wrong state" ) ;
366 Assert. That( NDOObjectState. Deleted == kp. NDOObjectState, "2. Wrong state" ) ;
367 ················pm.Abort();
368 Assert. That( NDOObjectState. Persistent == r. NDOObjectState, "1. Wrong state" ) ;
369 Assert. That( NDOObjectState. Persistent == kp. NDOObjectState, "2. Wrong state" ) ;
370 ············}
371 ········}
372
373 ········[Test]
374 public void TestAddRemoveSave( )
375 {
376 using ( var pm = PmFactory. NewPersistenceManager( ) )
377 ············{
378 ················pm.MakePersistent( r );
379 ················pm.Save();
380 r. AddKostenpunkt( kp ) ;
381 r. Löschen( kp ) ;
382 Assert. That( NDOObjectState. Transient == kp. NDOObjectState, "1. Wrong state" ) ;
383 ················pm.Save();
384 Assert. That( NDOObjectState. Transient == kp. NDOObjectState, "2. Wrong state" ) ;
385 ············}
386 ········}
387
388 ········[Test]
389 public void TestAddRemoveAbort( )
390 {
391 using ( var pm = PmFactory. NewPersistenceManager( ) )
392 ············{
393 ················pm.MakePersistent( r );
394 ················pm.Save();
395 r. AddKostenpunkt( kp ) ;
396 r. Löschen( kp ) ;
397 Assert. That( NDOObjectState. Transient == kp. NDOObjectState, "1. Wrong state" ) ;
398 ················pm.Abort();
399 Assert. That( NDOObjectState. Transient == kp. NDOObjectState, "2. Wrong state" ) ;
400 ············}
401 ········}
402
403 ········[Test]
404 public void TestClearRelatedObjectsSave( )
405 {
406 using ( var pm = PmFactory. NewPersistenceManager( ) )
407 {
408 ················for (int i = 0; i < 10; i++)
409 ················{
410 ····················r.AddKostenpunkt( CreateBeleg( i * 10 + 100 ) );
411 ················}
412 pm. MakePersistent( r ) ;
413 ················pm.Save();
414 ················IList rr = r.Kostenpunkte.ToList();
415 ················r.LöscheKostenpunkte();
416 Assert. That( 0 == r. Kostenpunkte. Count, "1. Wrong number of objects" ) ;
417 for ( int i = 0; i < 10; i++)
418 {
419 ····················Assert.That( NDOObjectState.Deleted == ( (Kostenpunkt) rr[i] ).NDOObjectState, "2. Wrong state" );
420 ················}
421 ················pm.Save();
422 Assert. That( 0 == r. Kostenpunkte. Count, "3. Wrong number of objects" ) ;
423 for ( int i = 0; i < 10; i++)
424 {
425 ····················Assert.That( NDOObjectState.Transient == ( (Kostenpunkt) rr[i] ).NDOObjectState, "4. Wrong state" );
426 ················}
427 ············}
428 ········}
429
430 ········[Test]
431 public void TestClearRelatedObjectsAbort( )
432 ········{
433 ············for(int i = 0; i < 10; i++) {
434 ················r.AddKostenpunkt(CreateBeleg(i*10+100));
435 ············}
436 using ( var pm = PmFactory. NewPersistenceManager( ) )
437 {
438 ················pm.MakePersistent( r );
439 ················pm.Save();
440 ················IList rr = r.Kostenpunkte.ToList();
441 ················r.LöscheKostenpunkte();
442 Assert. That( 0 == r. Kostenpunkte. Count, "1. Wrong number of objects" ) ;
443 for ( int i = 0; i < 10; i++)
444 {
445 ····················Assert.That( NDOObjectState.Deleted == ( (Kostenpunkt) rr[i] ).NDOObjectState, "2. Wrong state" );
446 ················}
447 ················pm.Abort();
448 Assert. That( 10 == r. Kostenpunkte. Count, "3. Wrong number of objects" ) ;
449 for ( int i = 0; i < 10; i++)
450 {
451 ····················Assert.That( NDOObjectState.Persistent == ( (Kostenpunkt) rr[i] ).NDOObjectState, "4. Wrong state" );
452 ················}
453 ············}
454 ········}
455
456 ········[Test]
457 public void TestAssignRelatedObjectsNullSave( )
458 {
459 for ( int i = 0; i < 3; i++)
460 ············{
461 ················r.AddKostenpunkt( CreateBeleg( i * 10 + 100 ) );
462 ············}
463 using ( var pm = PmFactory. NewPersistenceManager( ) )
464 {
465 ················pm.MakePersistent( r );
466 ················pm.Save();
467 ················IList rr = r.Kostenpunkte.ToList();
468 ················r.ErsetzeKostenpunkte();
469 Assert. That( r. Kostenpunkte == null, "No objects should be there" ) ;
470 for ( int i = 0; i < 3; i++)
471 {
472 ····················Assert.That( NDOObjectState.Deleted == ( (Kostenpunkt) rr[i] ).NDOObjectState, "2. Wrong state" );
473 ················}
474 ················pm.Save();
475 Assert. That( r. Kostenpunkte == null, "No objects should be there" ) ;
476 for ( int i = 0; i < 3; i++)
477 {
478 ····················Assert.That( NDOObjectState.Transient == ( (Kostenpunkt) rr[i] ).NDOObjectState, "4. Wrong state" );
479 ················}
480 ············}
481 ········}
482
483 ········[Test]
484 public void TestAssignRelatedObjectsNullAbort( )
485 {
486 for ( int i = 0; i < 3; i++)
487 ············{
488 ················r.AddKostenpunkt( CreateBeleg( i * 10 + 100 ) );
489 ············}
490 using ( var pm = PmFactory. NewPersistenceManager( ) )
491 {
492 ················pm.MakePersistent( r );
493 ················pm.Save();
494 ················IList rr = r.Kostenpunkte.ToList();
495 ················r.ErsetzeKostenpunkte();
496 Assert. That( r. Kostenpunkte == null, "No objects should be there" ) ;
497 for ( int i = 0; i < 3; i++)
498 {
499 ····················Assert.That( NDOObjectState.Deleted == ( (Kostenpunkt) rr[i] ).NDOObjectState, "2. Wrong state" );
500 ················}
501 ················pm.Abort();
502 Assert. That( 3 == r. Kostenpunkte. Count, "3. Wrong number of objects" ) ;
503 for ( int i = 0; i < 3; i++)
504 {
505 ····················Assert.That( NDOObjectState.Persistent == ( (Kostenpunkt) rr[i] ).NDOObjectState, "4. Wrong state" );
506 ················}
507 ············}
508 ········}
509
510 ········[Test]
511 public void TestAssignRelatedObjectsSave( )
512 {
513 for ( int i = 0; i < 3; i++)
514 ············{
515 ················r.AddKostenpunkt( CreateBeleg( i * 10 + 100 ) );
516 ············}
517 using ( var pm = PmFactory. NewPersistenceManager( ) )
518 {
519 ················pm.MakePersistent( r );
520 ················pm.Save();
521 ················List<Kostenpunkt> neueKostenpunkte = new List<Kostenpunkt>();
522 ················Kostenpunkt nr = CreateBeleg(50);
523 neueKostenpunkte. Add( nr ) ;
524
525 ················IList rr = r.Kostenpunkte.ToList();
526 r. ErsetzeKostenpunkte( neueKostenpunkte ) ;
527 Assert. That( 1 == r. Kostenpunkte. Count, "1. Wrong number of objects" ) ;
528 for ( int i = 0; i < 3; i++)
529 {
530 ····················Assert.That( NDOObjectState.Deleted == ( (Kostenpunkt) rr[i] ).NDOObjectState, "2. Wrong state" );
531 ················}
532 Assert. That( NDOObjectState. Created == nr. NDOObjectState, "3. Wrong state" ) ;
533
534 ················pm.Save();
535 Assert. That( 1 == r. Kostenpunkte. Count, "4. Wrong number of objects" ) ;
536 for ( int i = 0; i < 3; i++)
537 {
538 ····················Assert.That( NDOObjectState.Transient == ( (Kostenpunkt) rr[i] ).NDOObjectState, "5. Wrong state" );
539 ················}
540 ················Assert.That( NDOObjectState.Persistent == nr.NDOObjectState, "6. Wrong state" );
541 ············}
 
542 ········}
543
544 ········[Test]
545 public void TestAssignRelatedObjectsAbort( )
546 {
547 for ( int i = 0; i < 3; i++)
548 ············{
549 ················r.AddKostenpunkt( CreateBeleg( i * 10 + 100 ) );
550 ············}
551 using ( var pm = PmFactory. NewPersistenceManager( ) )
552 {
553 ················pm.MakePersistent( r );
554 ················pm.Save();
555 ················List<Kostenpunkt> neueKostenpunkte = new List<Kostenpunkt>();
556 ················Kostenpunkt nr = CreateBeleg(200);
557 neueKostenpunkte. Add( nr ) ;
558
559 ················IList rr = r.Kostenpunkte.ToList();
560 r. ErsetzeKostenpunkte( neueKostenpunkte ) ;
561 Assert. That( 1 == r. Kostenpunkte. Count, "1. Wrong number of objects" ) ;
562 for ( int i = 0; i < 3; i++)
563 {
564 ····················Assert.That( NDOObjectState.Deleted == ( (Kostenpunkt) rr[i] ).NDOObjectState, "2. Wrong state" );
565 ················}
566 Assert. That( NDOObjectState. Created == nr. NDOObjectState, "3. Wrong state" ) ;
567
568 ················pm.Abort();
569 Assert. That( 3 == r. Kostenpunkte. Count, "4. Wrong number of objects" ) ;
570 for ( int i = 0; i < 3; i++)
571 {
572 ····················Assert.That( NDOObjectState.Persistent == ( (Kostenpunkt) rr[i] ).NDOObjectState, "5. Wrong state" );
573 ················}
574 ················Assert.That( NDOObjectState.Transient == nr.NDOObjectState, "6. Wrong state" );
575 ············}
 
576 ········}
577
578
579 ········[Test]
580 public void TestHollow( )
581 {
582 r. AddKostenpunkt( kp ) ;
583 using ( var pm = PmFactory. NewPersistenceManager( ) )
584 ············{
585 ················pm.MakePersistent( r );
586 ················pm.Save();
587 pm. MakeHollow( r ) ;
588 Assert. That( NDOObjectState. Hollow == r. NDOObjectState, "1: Reise should be hollow" ) ;
589 Assert. That( NDOObjectState. Persistent == kp. NDOObjectState, "1: Kostenpunkt should be persistent" ) ;
590 ················var kostenpunkte = r.Kostenpunkte;
591
592 pm. MakeHollow( r, true ) ;
593 Assert. That( NDOObjectState. Hollow == r. NDOObjectState, "2: Reise should be hollow" ) ;
594 Assert. That( NDOObjectState. Hollow == kp. NDOObjectState, "2: Kostenpunkt should be hollow" ) ;
595
596 ················kostenpunkte = r.Kostenpunkte;
597 Assert. That( NDOObjectState. Persistent == r. NDOObjectState, "3: Reise should be persistent" ) ;
598 Assert. That( NDOObjectState. Hollow == kp. NDOObjectState, "3: Kostenpunkt should be hollow" ) ;
599 Assert. That( 200 == kp. Kosten, "3: Kostenpunkt should have correct Kosten" ) ;
600 Assert. That( NDOObjectState. Persistent == kp. NDOObjectState, "4: Kostenpunkt should be persistent" ) ;
601 ············}
602 ········}
603
604 ········[Test]
605 public void TestMakeAllHollow( )
606 {
607 r. AddKostenpunkt( kp ) ;
608 using ( var pm = PmFactory. NewPersistenceManager( ) )
609 ············{
610 ················pm.MakePersistent( r );
611 ················pm.Save();
612 ················pm.MakeAllHollow();
613 Assert. That( NDOObjectState. Hollow == r. NDOObjectState, "1: Reise should be hollow" ) ;
614 Assert. That( NDOObjectState. Hollow == kp. NDOObjectState, "1: Kostenpunkt should be hollow" ) ;
615 ············}
616 ········}
617
618
619 ········[Test]
620 public void TestMakeAllHollowUnsaved( )
621 {
622 using ( var pm = PmFactory. NewPersistenceManager( ) )
623 {
624 ················r.AddKostenpunkt( kp );
625 ················pm.MakePersistent( r );
626 ················pm.MakeAllHollow();··// before save, objects cannot be made hollow. => in locked objects
627 Assert. That( NDOObjectState. Created == r. NDOObjectState, "1: Reise should be created" ) ;
628 Assert. That( NDOObjectState. Created == kp. NDOObjectState, "1: Kostenpunkt should be created" ) ;
629 ············}
630 ········}
631
632 ········[Test]
633 public void TestLoadRelatedObjects( )
634 {
635 for ( int i = 0; i < 10; i++)
636 ············{
637 ················r.AddKostenpunkt( CreateBeleg( i * 10 + 100 ) );
638 ············}
639 using ( var pm = PmFactory. NewPersistenceManager( ) )
640 {
641 ················pm.MakePersistent( r );
642 ················pm.Save();
643 pm. MakeHollow( r, true ) ;
644
645 ················var kpunkte = r.Kostenpunkte.ToList();
646 Assert. That( 10 == kpunkte. Count, "Array size should be 10" ) ;
647
648 for ( int i = 0; i < 10; i++)
649 ················{
650 ····················Kostenpunkt rr = (Kostenpunkt)kpunkte[i];
651 Assert. That( NDOObjectState. Hollow == rr. NDOObjectState, "1: Kostenpunkt should be hollow" ) ;
652 #if !ORACLE && !MYSQL
653 Assert. That( i * 10 + 100 == rr. Kosten, "2: Kostenpunkt should be in right order" ) ;
654 #endif
655 ················}
656
657
658
659 ················pm.MakeAllHollow();
660 ················pm.UnloadCache();
661 ················var kpunkte2 = r.Kostenpunkte.ToList();
662 for ( int i = 0; i < 10; i++)
663 ················{
664 ····················Kostenpunkt r1 = (Kostenpunkt)kpunkte[i];
665 ····················Kostenpunkt r2 = (Kostenpunkt)kpunkte2[i];
666 #if !ORACLE && !MYSQL
667 Assert. That( i * 10 + 100 == r1. Kosten, "3: Kostenpunkt should be in right order" ) ;
668 #endif
669 Assert. That( r1 != r2, "Objects should be different" ) ;
670 ················}
671 ············}
672 ········}
673
674 ········[Test]
675 public void TestLoadRelatedObjectsSave( )
676 {
677 using ( var pm = PmFactory. NewPersistenceManager( ) )
678 ············{
679 ················pm.MakePersistent( r );
680 ················pm.Save();
681 for ( int i = 0; i < 10; i++)
682 {
683 ····················r.AddKostenpunkt( CreateBeleg( i * 10 + 100 ) );
684 ················}
685 ················pm.Save();
686 pm. MakeHollow( r, true ) ;
687
688 ················IList reisen = r.Kostenpunkte.ToList();
689
690 for ( int i = 0; i < 10; i++)
691 ················{
692 ····················Kostenpunkt rr = (Kostenpunkt)reisen[i];
693 Assert. That( NDOObjectState. Hollow == rr. NDOObjectState, "1: Kostenpunkt should be hollow" ) ;
694 #if !ORACLE && !MYSQL
695 Assert. That( i * 10 + 100 == rr. Kosten, "2: Kostenpunkt should be in right order" ) ;
696 #endif
697 ················}
 
698
699 ················pm.MakeAllHollow();
700 ················pm.UnloadCache();
701 ················IList reisen2 = r.Kostenpunkte.ToList();
702 for ( int i = 0; i < 10; i++)
703 ················{
704 ····················Kostenpunkt r1 = (Kostenpunkt)reisen[i];
705 ····················Kostenpunkt r2 = (Kostenpunkt)reisen2[i];
706 #if !ORACLE && !MYSQL
707 Assert. That( i * 10 + 100 == r1. Kosten, "3: Kostenpunkt should be in right order" ) ;
708 #endif
709 Assert. That( r1 != r2, "Objects should be different" ) ;
710 ················}
711 ············}
712 ········}
713
714 ········[Test]
715 public void TestExtentRelatedObjects( )
716 {
717 r. AddKostenpunkt( kp ) ;
718 using ( var pm = PmFactory. NewPersistenceManager( ) )
719 ············{
720 ················pm.MakePersistent( r );
721 ················pm.Save();
722 Assert. That( NDOObjectState. Persistent == r. NDOObjectState, "0: Reise should be persistent" ) ;
723 ················IList liste = pm.GetClassExtent(typeof(Reise));
724 r = ( Reise) liste[0];
725 Assert. That( 1 == liste. Count, "1: Number of Reise objects is wrong" ) ;
726 Assert. That( NDOObjectState. Persistent == r. NDOObjectState, "1: Reise should be persistent" ) ;
727 Assert. That( r. Kostenpunkte != null, "2. Relation is missing" ) ;
728 Assert. That( 1 == r. Kostenpunkte. Count, "3. Wrong number of objects" ) ;
729 Assert. That( NDOObjectState. Persistent == ( ( Kostenpunkt) r. Kostenpunkte[0] ) . NDOObjectState, "4. : Kostenpunkt should be hollow" ) ;
730
731 ················pm.UnloadCache();
732 liste = pm. GetClassExtent( typeof( Reise ) ) ;
733 r = ( Reise) liste[0];
734 Assert. That( NDOObjectState. Hollow == r. NDOObjectState, "5: Reise should be hollow" ) ;
735 Assert. That( r. Kostenpunkte != null, "6. Relation is missing" ) ;
736 Assert. That( 1 == r. Kostenpunkte. Count, "7. Wrong number of objects" ) ;
737 Assert. That( NDOObjectState. Hollow == ( ( Kostenpunkt) r. Kostenpunkte[0] ) . NDOObjectState, "8. : Kostenpunkt should be hollow" ) ;
738
739 ················pm.UnloadCache();
740 liste = pm. GetClassExtent( typeof( Reise ) , false ) ;
741 r = ( Reise) liste[0];
742 Assert. That( NDOObjectState. Persistent == r. NDOObjectState, "9: Reise should be persistent" ) ;
743 Assert. That( r. Kostenpunkte != null, "10. Relation is missing" ) ;
744 Assert. That( 1 == r. Kostenpunkte. Count, "11. Wrong number of objects" ) ;
745 Assert. That( NDOObjectState. Hollow == ( ( Kostenpunkt) r. Kostenpunkte[0] ) . NDOObjectState, "12. : Kostenpunkt should be hollow" ) ;
746 ············}
747 ········}
748
749 ········[Test]
750 ········public void TestJoinQuery()
751 ········{
752 ············using (var pm = PmFactory.NewPersistenceManager())
753 ············{
 
754
755 ················Person p = new Person();
756 ················p.FirstName = "Mirko";
757 ················p.LastName = "Matytschak";
758 ················p.Moniker = "Hallo";
759 ················Adresse a1 = new Adresse();
760 ················a1.Lkz = "D";
761 ················a1.Plz = "83646";
762 ················a1.Straße = "Nockhergasse 7";
763 ················a1.Ort = "Bad Tölz";
764
765 ················Adresse a2 = new Adresse();
766 ················a2.Ort = "Mönchen";
767 ················a2.Plz = "80331";
768 ················a2.Straße = "Isartorplatz 5";
769 ················a2.Lkz = "D";
770
771 ················Institution i = new Institution();
772 ················i.FirstName = "Schnulli";
773 ················i.LastName = "Wauwau";
774 ················i.Hausmeister = "Möller";
775
776 pm. MakePersistent( a1 ) ;
777 pm. MakePersistent( a2 ) ;
778 pm. MakePersistent( p ) ;
779 pm. MakePersistent( i ) ;
780 i. AddAdresse( a1 ) ;
781 p. AddAdresse( a1 ) ;
782 p. AddAdresse( a2 ) ;
783 ················pm.Save();
784 ················pm.UnloadCache();
785
786 ················IQuery q = new NDOQuery<Contact>(pm, $"addresses.plz = '{a2.Plz}'");
787 ················IList l = q.Execute();
788 Assert. That( 1 == l. Count, "Wrong number of contacts" ) ;
789 ············}
790 ········}
791
792 ········[Test]
793 ········public void TestPolymorphicCondition()
794 ········{
795 r. AddKostenpunkt( kp ) ;
796 using ( var pm = PmFactory. NewPersistenceManager( ) )
797 {
798 ················pm.MakePersistent( r );
799 ················pm.Save();
800
801 ················pm.UnloadCache();
802 ················NDOQuery<Reise> q = new NDOQuery<Reise>(pm, "belege.datum" + " = " + "{0}");
803 q. Parameters. Add( DateTime. Now. Date ) ;
804 r = ( Reise) q. ExecuteSingle( true ) ;
805 Assert. That( r != null, "Reise not found" ) ;
806 Assert. That( r. Kostenpunkte. Count > 0, "No Beleg" ) ;
807 Assert. That( r. Kostenpunkte[0] != null, "Beleg not found" ) ;
808 ············}
809 ········}
810
811 ········[Test]
812 ········public void TestSortedQueryAsc()
813 ········{
814 using ( var pm = PmFactory. NewPersistenceManager( ) )
815 ············{
816
817 r. AddKostenpunkt( kp ) ;
818 ················DateTime yesterday = DateTime.Today - new TimeSpan(1, 0, 0, 0);
819 ················kp.Datum = yesterday;
820 r. AddKostenpunkt( kp = CreatePkw( ) ) ;
821 ················kp.Datum = DateTime.Today;
822 pm. MakePersistent( r ) ;
823 ················pm.Save();
824
825 ················pm.UnloadCache();
826 ················IQuery q = new NDOQuery<Kostenpunkt>(pm);
827 q. Orderings. Add( new AscendingOrder( "datum" ) ) ;
828 ················IList l = q.Execute();
829 Assert. That( 2 == l. Count, "Count wrong" ) ;
830 Assert. That( yesterday == ( ( Kostenpunkt) l[0] ) . Datum, "Order wrong" ) ;
831 Assert. That( DateTime. Today == ( ( Kostenpunkt) l[1] ) . Datum, "Wrong object" ) ;
832 ············}
833 ········}
834
835 ········[Test]
836 ········public void TestSortedQueryDesc()
837 ········{
838 ············using (var pm = PmFactory.NewPersistenceManager())
839 ············{
840 r. AddKostenpunkt( kp ) ;
 
 
841 ················DateTime yesterday = DateTime.Today - new TimeSpan(1, 0, 0, 0);
842 ················kp.Datum = yesterday;
843 r. AddKostenpunkt( kp = CreatePkw( ) ) ;
844 ················kp.Datum = DateTime.Today;
845 pm. MakePersistent( r ) ;
846 ················pm.Save();
847
848 ················pm.UnloadCache();
849 ················IQuery q = new NDOQuery<Kostenpunkt>(pm);
850 q. Orderings. Add( new DescendingOrder( "datum" ) ) ;
851 ················IList l = q.Execute();
852
853 Assert. That( 2 == l. Count, "Count wrong" ) ;
854 Assert. That( DateTime. Today == ( ( Kostenpunkt) l[0] ) . Datum, "Order wrong" ) ;
855 Assert. That( yesterday == ( ( Kostenpunkt) l[1] ) . Datum, "Wrong object" ) ;
856 ············}
857 ········}
858
859 ········[Test]
860 ········public void TestSortedQueryAscOneNull()
861 ········{
862 ············using (var pm = PmFactory.NewPersistenceManager())
863 ············{
 
864
865 r. AddKostenpunkt( kp ) ;
866 ················kp.Datum = DateTime.MinValue;··// DbNull
867 r. AddKostenpunkt( kp = CreatePkw( ) ) ;
868 ················kp.Datum = DateTime.Today;
869 pm. MakePersistent( r ) ;
870 ················pm.Save();
871
872 ················pm.UnloadCache();
873 ················IQuery q = new NDOQuery<Kostenpunkt>(pm);
874 q. Orderings. Add( new AscendingOrder( "datum" ) ) ;
875 ················IList l = q.Execute();
876 ················//pm.VerboseMode = false;
877 Assert. That( 2 == l. Count, "Count wrong" ) ;
878 Assert. That( DateTime. MinValue == ( ( Kostenpunkt) l[0] ) . Datum, "Order wrong" ) ;
879 Assert. That( DateTime. Today == ( ( Kostenpunkt) l[1] ) . Datum, "Wrong object" ) ;
880 ············}
881 ········}
882
883 ········[Test]
884 ········public void TestSortedQueryBothNull()
885 ········{
886 using ( var pm = PmFactory. NewPersistenceManager( ) )
887 ············{
888
889 r. AddKostenpunkt( kp ) ;
890 ················kp.Datum = DateTime.MinValue;··// DbNull
891 r. AddKostenpunkt( kp = CreatePkw( ) ) ;
892 ················kp.Datum = DateTime.MinValue;··// DbNull
893 pm. MakePersistent( r ) ;
894 ················pm.Save();
895
896 ················pm.UnloadCache();
897 ················IQuery q = new NDOQuery<Kostenpunkt>(pm);
898 q. Orderings. Add( new AscendingOrder( "datum" ) ) ;
899 ················IList l = q.Execute();
900 ················//pm.VerboseMode = false;
901 Assert. That( 2 == l. Count, "Count wrong" ) ;
902 Assert. That( DateTime. MinValue == ( ( Kostenpunkt) l[0] ) . Datum, "Wrong Date #1" ) ;
903 Assert. That( DateTime. MinValue == ( ( Kostenpunkt) l[1] ) . Datum, "Wrong Date #2" ) ;
904 ············}
905 ········}
906
907 ········[Test]
908 ········public void TestSortedQueryDescOneNull()
909 ········{
910 ············using (var pm = PmFactory.NewPersistenceManager())
911 ············{
912 r. AddKostenpunkt( kp ) ;
 
913 ················kp.Datum = DateTime.MinValue;
914 r. AddKostenpunkt( kp = CreatePkw( ) ) ;
915 ················kp.Datum = DateTime.Today;
916 pm. MakePersistent( r ) ;
917 ················pm.Save();
918
919 ················pm.UnloadCache();
920 ················IQuery q = new NDOQuery<Kostenpunkt>(pm);
921 q. Orderings. Add( new DescendingOrder( "datum" ) ) ;
922 ················IList l = q.Execute();
923 ················//pm.VerboseMode = false;
924 Assert. That( 2 == l. Count, "Count wrong" ) ;
925 Assert. That( DateTime. Today == ( ( Kostenpunkt) l[0] ) . Datum, "Order wrong" ) ;
926 Assert. That( DateTime. MinValue == ( ( Kostenpunkt) l[1] ) . Datum, "Wrong object" ) ;
927 ············}
928 ········}
929
930
931 ········[Test]
932 ········public void TestQueryForSingleObject()
933 ········{
934 using ( var pm = PmFactory. NewPersistenceManager( ) )
935 ············{
936 ················Kostenpunkt kp2 = CreatePkw(100);
937 r. AddKostenpunkt( kp ) ;
938 r. AddKostenpunkt( kp2 ) ;
939 pm. MakePersistent( r ) ;
940 ················pm.Save();
941 ················pm.UnloadCache();
942 ················NDOQuery<Reise> q = new NDOQuery<Reise>(pm, "belege.datum" + " = " + "{0}");
943 q. Parameters. Add( DateTime. Now. Date ) ;
944 ················IList l = q.Execute();
945 Assert. That( 1 == l. Count, "Count wrong" ) ;
946 ············}
947 ········}
948
949
950 ········[Test]
951 ········public void TestPolyDelete()
952 ········{
953 using ( var pm = PmFactory. NewPersistenceManager( ) )
954 ············{
955 ················Kostenpunkt kp2 = CreatePkw(100);
956 r. AddKostenpunkt( kp ) ;
957 r. AddKostenpunkt( kp2 ) ;
958 pm. MakePersistent( r ) ;
959 ················pm.Save();
960 ················pm.UnloadCache();
961 ················NDOQuery<Reise> q = new NDOQuery<Reise>(pm, "belege.datum" + " = " + "{0}");
962 q. Parameters. Add( DateTime. Now. Date ) ;
963 ················IList l = q.Execute();
964 Assert. That( 1 == l. Count, "Count wrong" ) ;
965 ················r = (Reise) l[0];
966 pm. Delete( r ) ;
967 ················pm.Save();
968 ············}
969 ········}
970
971
972 ········[Test]
973 ········public void RelationTest()
974 ········{
975 ············using (var pm = PmFactory.NewPersistenceManager())
976 ············{
 
977 ················NDOMapping mapping = pm.NDOMapping;
978 ················Class reiseClass = mapping.FindClass(typeof(Reise));
979 ················Class pkwClass = mapping.FindClass(typeof(PKWFahrt));
980 Assert. That( reiseClass != null, "Mapping for Reise not found" ) ;
981 Assert. That( pkwClass != null, "Mapping for pkw not found" ) ;
982 ················Relation r1 = reiseClass.FindRelation("belege");
983 Assert. That( r1 != null, "Relation not found #1" ) ;
984 Assert. That( r1. ForeignRelation != null, "ForeignRelation of Reise not found" ) ;
985 ················Relation r2 = pkwClass.FindRelation("reise");
986 Assert. That( r2 != null, "Relation not found #2" ) ;
987 Assert. That( r2. ForeignRelation != null, "ForeignRelation of PKWFahrt not found" ) ;
988 Assert. That( r1 == r2. ForeignRelation, "Back relation wrong" ) ;
989 ················//············Debug.WriteLine(r1.Parent.FullName + "->" + r1.ReferencedTypeName);
990 ················//············Debug.WriteLine(r1.ForeignRelation.Parent.FullName + "->" + r1.ForeignRelation.ReferencedTypeName);
991 ················//············Debug.WriteLine(r2.Parent.FullName + "->" + r2.ReferencedTypeName);
992 ················//············Debug.WriteLine(r2.ForeignRelation.Parent.FullName + "->" + r2.ForeignRelation.ReferencedTypeName);
993 ············}
994 ········}
995
996
997 ········private Kostenpunkt CreateBeleg(double betrag)
998 ········{
999 ············return new Beleg("Taxi", betrag);
1000 ········}
1001
1002 ········private Kostenpunkt CreateBeleg() {
1003 ············return new Beleg("Flug", 200);
1004 ········}
1005
1006 ········private Kostenpunkt CreatePkw() {
1007 ············return CreatePkw(100);
1008 ········}
1009
1010 ········private Kostenpunkt CreatePkw(double km) {
1011 ············return new PKWFahrt(km);
1012 ········}
1013
1014 ········private Reise CreateReise(string zweck) {
1015 ············Reise r = new Reise();
1016 ············r.Zweck = zweck;
1017 ············return r;
1018 ········}
1019 ····}
1020 }
1021