Datei: IntegrationTests/IntegrationTests/NDOReiseTests.cs

Last Commit (9d1552b)
1 //
2 // Copyright (c) 2002-2016 Mirko Matytschak
3 // (www.netdataobjects.de)
4 //
5 // Author: Mirko Matytschak
6 //
7 // Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
8 // documentation files (the "Software"), to deal in the Software without restriction, including without limitation
9 // the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
10 // Software, and to permit persons to whom the Software is furnished to do so, subject to the following
11 // conditions:
12
13 // The above copyright notice and this permission notice shall be included in all copies or substantial portions
14 // of the Software.
15 //
16 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
17 // TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
19 // CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
20 // DEALINGS IN THE SOFTWARE.
21
22
23 using System;
24 using System.Collections;
25 using NUnit.Framework;
26 using NDO;
27 using Reisekosten;
28 using Reisekosten.Personal;
29
30 namespace NdoUnitTests
31 {
32 ····[TestFixture]
33 public class NDOReiseTests
34 ····{
35
36 ········public NDOReiseTests()
37 ········{
38 ········}
39
40 ········private PersistenceManager pm;
41 ········private Reise r;
42 ········private Mitarbeiter m;
43
44 ········[SetUp]
45 ········public void Setup()
46 ········{
47 ············pm = PmFactory.NewPersistenceManager();
48 ············r = CreateReise( "ADC" );
49 ············m = CreateMitarbeiter();
50 ········}
51
52 ········[TearDown]
53 ········public void TearDown()
54 ········{
55 ············try
56 ············{
57 ················pm.Abort();
58 ················IList mitarbeiterListe = pm.GetClassExtent( typeof( Mitarbeiter ), false );
59 ················//················Console.WriteLine("TearDown löscht " + mitarbeiterListe.Count + " Mitarbeiter");
60 ················pm.Delete( mitarbeiterListe );
61 ················pm.Save();
62 ················IList reiseListe = pm.GetClassExtent( typeof( Reise ), false );
63 ················//················Console.WriteLine("TearDown löscht " + reiseListe.Count + " Reisen");
64 ················pm.Delete( reiseListe );
65 ················pm.Save();
66 ················pm.Close();
67 ············}
68 ············catch (Exception ex)
69 ············{
70 ················System.Console.Error.WriteLine( "Exception in TearDown: " + ex );
71 ············}
72 ········}
73
74 ········[Test]
75 ········public void TestEmptyTransactionSave()
76 ········{
77 ············pm.Save();
78 ········}
79
80 ········[Test]
81 ········public void TestEmptyTransactionAbort()
82 ········{
83 ············pm.Abort();
84 ········}
85
86 ········[Test]
87 ········public void EmptyDB()
88 ········{
89 ············IList reiseListe = pm.GetClassExtent( typeof( Reise ), true );
90 ············pm.Delete( reiseListe );
91 ············pm.Save();
92 ············IList mitarbeiterListe = pm.GetClassExtent( typeof( Mitarbeiter ), true );
93 ············pm.Delete( mitarbeiterListe );
94 ············pm.Save();
95 ········}
96
97 ········[Test]
98 ········public void TestObjectCreation()
99 ········{
100 ············m.Hinzufuegen( r );
101 ············pm.MakePersistent( m );
102 ············Assert.That(r.NDOObjectId != null, "ObjectId should be valid" );
103 ············Assert.That(NDOObjectState.Created ==··r.NDOObjectState, "Status wrong" );
104 ········}
105
106 ········[Test]
107 ········public void TestObjectCreationSave()
108 ········{
109 ············m.Hinzufuegen( r );
110 ············pm.MakePersistent( m );
111 ············pm.Save();
112 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "Status wrong" );
113 ········}
114
115 ········[Test]
116 ········public void TestObjectCreationSaveChanged()
117 ········{
118 ············m.Hinzufuegen( r );
119 ············pm.MakePersistent( m );
120 ············r.Zweck = "Test";
121 ············pm.Save();
122 ············Assert.That("Test" ==··r.Zweck, "Zweck wrong" );
123 ········}
124
125 ········[Test]
126 ········public void TestObjectCreationAbort()
127 ········{
128 ············m.Hinzufuegen( r );
129 ············pm.MakePersistent( m );
130 ············pm.Abort();
131 ············Assert.That(r.NDOObjectId == null, "Transient object shouldn't have ID" );
132 ············Assert.That(((IPersistenceCapable)r).NDOStateManager == null, "Transient object shouldn't have state manager" );
133 ············Assert.That(NDOObjectState.Transient ==··r.NDOObjectState, "Status wrong" );
134 ········}
135
136 ········[Test]
137 ········public void TestObjectCreationAbortChanged()
138 ········{
139 ············m.Hinzufuegen( r );
140 ············pm.MakePersistent( m );
141 ············r.Zweck = "Möller";
142 ············pm.Abort();
143 ············Assert.That("ADC" ==··r.Zweck, "Nachname wrong" );
144 ········}
145
146 ········[Test]
147 ········public void TestObjectId()
148 ········{
149 ············m.Hinzufuegen( r );
150 ············pm.MakePersistent( m );
151 ············ObjectId id = r.NDOObjectId;
152 ············ObjectId id2 = new ObjectId( id );
153 ············Assert.That(r.NDOObjectId ==··id, "IDs should be equal" );
154 ············Assert.That(r.NDOObjectId ==··id2, "IDs should be equal" );
155 ············if (!pm.HasOwnerCreatedIds && r.NDOObjectId.Id[0] is Int32)
156 ················Assert.That( (int)id.Id[0] < 0, "Negative key in DS" );
157 ············pm.Save();
158 ············Assert.That(r.NDOObjectId ==··id, "IDs should be equal" );
159 ············Assert.That(r.NDOObjectId ==··id2, "IDs should be equal" );
160 ············if (!pm.HasOwnerCreatedIds && r.NDOObjectId.Id[0] is Int32)
161 ················Assert.That( (int)id.Id[0] > 0, "Positive key in DB" );
162 ········}
163
164 ········[Test]
165 ········public void TestCreateDeleteTransitionSave()
166 ········{
167 ············m.Hinzufuegen( r );
168 ············pm.MakePersistent( m );
169 ············pm.Delete( m );
170 ············Assert.That(r.NDOObjectId == null, "Transient object shouldn't have ID" );
171 ············Assert.That(((IPersistenceCapable)r).NDOStateManager == null, "Transient object shouldn't have state manager" );
172 ············Assert.That(NDOObjectState.Transient ==··r.NDOObjectState, "Status wrong" );
173 ············pm.Save();
174 ············Assert.That(r.NDOObjectId == null, "Transient object shouldn't have ID" );
175 ············Assert.That(((IPersistenceCapable)r).NDOStateManager == null, "Transient object shouldn't have state manager" );
176 ············Assert.That(NDOObjectState.Transient ==··r.NDOObjectState, "Status wrong" );
177 ········}
178
179 ········[Test]
180 ········public void TestCreateDeleteTransitionAbort()
181 ········{
182 ············m.Hinzufuegen( r );
183 ············pm.MakePersistent( m );
184 ············ObjectId id = m.NDOObjectId;
185 ············pm.Delete( m );
186 ············pm.Abort();
187 ············Assert.That(r.NDOObjectId == null, "Transient object shouldn't have ID" );
188 ············Assert.That(((IPersistenceCapable)r).NDOStateManager == null, "Transient object shouldn't have state manager" );
189 ············Assert.That(NDOObjectState.Transient ==··r.NDOObjectState, "Status wrong" );
190 ········}
191
192 ········[Test]
193 ········public void TestCleanupCache()
194 ········{
195 ············m.Hinzufuegen( r );
196 ············pm.MakePersistent( m );
197 ············pm.CleanupCache();
198 ············Assert.That(Object.ReferenceEquals(r, pm.FindObject( r.NDOObjectId )), "Getting same object twice should return same object" );
199 ············pm.Save();
200 ············pm.CleanupCache();
201 ············Assert.That(Object.ReferenceEquals(r, pm.FindObject( r.NDOObjectId )), "Getting same object twice should return same object" );
202 ············ObjectId id = r.NDOObjectId;
203 ············r = null;
204 ············pm.CleanupCache();
205 ············Assert.That(pm.FindObject( id ) != null, "Should find object" );
206 ········}
207
208 ········[Test]
209 ········public void TestUnloadCache()
210 ········{
211 ············m.Hinzufuegen( r );
212 ············pm.MakePersistent( m );
213 ············Assert.That(Object.ReferenceEquals(r, pm.FindObject( r.NDOObjectId )), "Getting same object twice should return same object" );
214 ············pm.Save();
215 ············pm.UnloadCache();
216 ············Assert.That( r != pm.FindObject( r.NDOObjectId ), "Getting same object twice should return different objects" );
217 ············ObjectId id = r.NDOObjectId;
218 ············r = null;
219 ············pm.UnloadCache();
220 ············Assert.That(pm.FindObject( id ) != null, "Should find object" );
221 ········}
222
223 ········[Test]
224 ········public void TestClassExtent()
225 ········{
226 ············ArrayList rliste = new ArrayList();
227 ············for (int i = 0; i < 100; i++)
228 ············{
229 ················Reise mr = CreateReise( "" + i );
230 ················m.Hinzufuegen( mr );
231 ················rliste.Add( mr );
232 ············}
233 ············pm.MakePersistent( m );
234
235 ············IList ReiseListe = pm.GetClassExtent( typeof( Reise ) );
236 ············Assert.That(0 ==··ReiseListe.Count, "Current extent should be empty" );
237 ············pm.Save();
238
239 ············ReiseListe = pm.GetClassExtent( typeof( Reise ) );
240 ············Assert.That(100 ==··ReiseListe.Count, "Number of read objects is wrong" );
241 ············// Check that all objects come from cache...
242 ············foreach (Reise m1 in ReiseListe)
243 ············{
244 ················Assert.That(NDOObjectState.Persistent ==··m1.NDOObjectState, "Wrong state" );
245 ············}
246
247 ············rliste.Clear();
248 ············rliste = null;
249 ············ReiseListe.Clear();
250 ············ReiseListe = null;
251 ············//pm.CleanupCache();
252 ············pm.UnloadCache();
253 ············ReiseListe = pm.GetClassExtent( typeof( Reise ) );
254 ············Assert.That(100 ==··ReiseListe.Count, "Number of read objects is wrong" );
255 ············// Check that all objects are reloaded
256 ············foreach (Reise m1 in ReiseListe)
257 ············{
258 ················Assert.That(NDOObjectState.Hollow ==··m1.NDOObjectState, "Wrong state" );
259 ············}
260 ········}
261
262 ········[Test]
263 ········public void TestDeleteHollow()
264 ········{
265 ············m.Hinzufuegen( r );
266 ············pm.MakePersistent( m );
267 ············pm.Save();
268 ············pm.UnloadCache();
269 ············r = (Reise)pm.FindObject( r.NDOObjectId );
270 ············Assert.That(NDOObjectState.Hollow ==··r.NDOObjectState, "Wrong state #1" );
271 ············pm.Delete( r );
272 ············Assert.That(NDOObjectState.Deleted ==··r.NDOObjectState, "Wrong state #2" );
273 ············pm.Abort();
274 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "Wrong state #3" );
275 ············pm.UnloadCache();
276 ············r = (Reise)pm.FindObject( r.NDOObjectId );
277 ············Assert.That(NDOObjectState.Hollow ==··r.NDOObjectState, "Wrong state #4" );
278 ············pm.Delete( r );
279 ············pm.Save();
280 ············Assert.That(NDOObjectState.Transient ==··r.NDOObjectState, "Wrong state #5" );
281
282 ············IList l = pm.GetClassExtent( typeof( Reise ) );
283 ············Assert.That(0 ==··l.Count, "Number of read objects is wrong" );
284 ········}
285
286 ········[Test]
287 ········public void TestDeletePersistent()
288 ········{
289 ············m.Hinzufuegen( r );
290 ············pm.MakePersistent( m );
291 ············pm.Save();
292 ············pm.Delete( r );
293 ············Assert.That(NDOObjectState.Deleted ==··r.NDOObjectState, "Wrong state #1" );
294 ············IList l = pm.GetClassExtent( typeof( Reise ) );
295 ············Assert.That(1 ==··l.Count, "Number of read objects is wrong" );
296 ············pm.Save();
297 ············l = pm.GetClassExtent( typeof( Reise ) );
298 ············Assert.That(0 ==··l.Count, "Number of read objects is wrong" );
299 ············pm.MakeHollow( m );··// Reread during TearDown will not load Reise anymore.
300 ········}
301
302 ········[Test]
303 ········public void TestDeletePersistentDirty()
304 ········{
305 ············m.Hinzufuegen( r );
306 ············pm.MakePersistent( m );
307 ············pm.Save();
308 ············r.Zweck = "Test";
309 ············Assert.That(NDOObjectState.PersistentDirty ==··r.NDOObjectState, "Wrong state #1" );
310 ············pm.Delete( r );
311 ············Assert.That(NDOObjectState.Deleted ==··r.NDOObjectState, "Wrong state #1" );
312 ············pm.Abort();
313 ············Assert.That("ADC" ==··r.Zweck, "Name shouldn't be changed" );
314 ············pm.Delete( r );
315 ············pm.Save();
316 ············IList l = pm.GetClassExtent( typeof( Reise ) );
317 ············Assert.That(0 ==··l.Count, "Number of read objects is wrong" );
318 ············pm.MakeHollow( m );··// Reread during TearDown will not load Reise anymore.
319 ········}
320
321 ········[Test]
322 ········public void TestPersistentDirty()
323 ········{
324 ············m.Hinzufuegen( r );
325 ············pm.MakePersistent( m );
326 ············pm.Save();
327 ············r.Zweck = "Test";
328 ············Assert.That(NDOObjectState.PersistentDirty ==··r.NDOObjectState, "Wrong state #1" );
329 ············pm.Abort();
330 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "Wrong state #2" );
331 ············Assert.That("ADC" ==··r.Zweck, "Name shouldn't be changed" );
332 ········}
333
334 ········[Test]
335 ········public void TestMakeTransient()
336 ········{
337 ············m.Hinzufuegen( r );
338 ············pm.MakePersistent( m );
339 ············pm.Save();
340 ············ObjectId id = r.NDOObjectId;
341 ············pm.MakeTransient( r );
342 ············Assert.That(((IPersistenceCapable)r).NDOStateManager == null, "Transient object shouldn't have state manager" );
343 ············Assert.That(NDOObjectState.Transient ==··r.NDOObjectState, "Wrong state #1" );
344 ············Assert.That( id.IsValid(), "Id should still be valid #1" );
345 ············r = (Reise)pm.FindObject( id );
346 ············Assert.That(NDOObjectState.Hollow ==··r.NDOObjectState, "Wrong state #2" );
347 ············pm.MakeTransient( r );
348 ············Assert.That(((IPersistenceCapable)r).NDOStateManager == null, "Transient object shouldn't have state manager" );
349 ············Assert.That(NDOObjectState.Transient ==··r.NDOObjectState, "Wrong state #3" );
350 ············Assert.That( id.IsValid(), "Id should still be valid #2" );
351 ············r = (Reise)pm.FindObject( id );
352 ············pm.Delete( r );
353 ············pm.Save();
354 ············pm.MakeHollow( m );··// Reread during TearDown will not load Reise anymore.
355 ········}
356
357 ········[Test]
358 ········public void TestMakeHollow()
359 ········{
360 ············m.Hinzufuegen( r );
361 ············pm.MakePersistent( m );
362 ············pm.Save();
363 ············pm.MakeHollow( r );
364 ············Assert.That(NDOObjectState.Hollow ==··r.NDOObjectState, "Wrong state #1" );
365 ············string access = r.Zweck;
366 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "Wrong state #2" );
367 ············pm.MakeAllHollow();
368 ············Assert.That(NDOObjectState.Hollow ==··r.NDOObjectState, "Wrong state #3" );
369 ········}
370
371 ········[Test]
372 ········public void TestChangeHollow()
373 ········{
374 ············m.Hinzufuegen( r );
375 ············pm.MakePersistent( m );
376 ············pm.Save();
377 ············pm.MakeHollow( r );
378 ············r.Zweck = "Test";
379 ············pm.Abort();
380 ············Assert.That("ADC" ==··r.Zweck, "Name shouldn't be changed" );
381 ············pm.MakeHollow( r );
382 ············r.Zweck = "Test";
383 ············pm.Save();
384 ············Assert.That("Test" ==··r.Zweck, "Name should be changed" );
385 ········}
386
387 ········[Test]
388 ········public void TestRelatedObject()
389 ········{
390 ············m.Hinzufuegen( r );
391 ············pm.MakePersistent( m );
392 ············pm.Save();
393 ············pm.MakeHollow( r );
394 ············r.Zweck = "Test";
395 ············pm.Save();··// Bug would overwrite foreign key in database.
396 ············Assert.That("Test" ==··r.Zweck, "Name should be changed" );
397 ············r = null;
398 ············ObjectId id = m.NDOObjectId;
399 ············m = null;
400 ············pm.UnloadCache();
401 ············m = (Mitarbeiter)pm.FindObject( id );
402 ············Assert.That(1 ==··m.Reisen.Count, "Number of children" );
403 ········}
404
405 ········[Test]
406 ········public void TestRefreshFailed()
407 ········{
408 ············var thrown = false;
409 ············try
410 ············{
411 ················pm.Refresh( r );
412 ············}
413 ············catch (NDOException)
414 ············{
415 ················thrown = true;
416 ············}
417 ············Assert.That(true ==··thrown );
418 ········}
419
420 ········[Test]
421 ········public void TestRefresh()
422 ········{
423 ············m.Hinzufuegen( r );
424 ············pm.MakePersistent( m );
425 ············pm.Save();
426 ············pm.MakeHollow( r );
427 ············pm.Refresh( r );
428 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "Wrong state #1" );
429 ············pm.Refresh( r );
430 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "Wrong state #2" );
431 ············ObjectId id = r.NDOObjectId;
432
433 ············PersistenceManager pm2 = PmFactory.NewPersistenceManager();
434 ············Reise m2 = (Reise)pm2.FindObject( id );
435 ············Assert.That(m2 != null, "Cannot load object" );
436 ············m2.Zweck = "Test";
437 ············pm2.Save();
438 ············pm2.Close();
439
440 ············Assert.That("ADC" ==··r.Zweck, "Wrong name #1" );
441 ············Assert.That("Test" ==··m2.Zweck, "Wrong name #2" );
442 ············pm.Refresh( r );
443 ············Assert.That("Test" ==··r.Zweck, "Wrong name #3" );
444 ········}
445
446 ········[Test]
447 ········public void TestHollowMode()
448 ········{
449 ············m.Hinzufuegen( r );
450 ············pm.MakePersistent( m );
451 ············pm.HollowMode = true;
452 ············pm.Save();
453 ············Assert.That(NDOObjectState.Hollow ==··r.NDOObjectState, "Wrong state #1" );
454 ············r.Zweck = "Test";
455 ············pm.Abort();
456 ············Assert.That(NDOObjectState.Hollow ==··r.NDOObjectState, "Wrong state #2" );
457 ············r.Zweck = "Test";
458 ············pm.Save();
459 ············Assert.That(NDOObjectState.Hollow ==··r.NDOObjectState, "Wrong state #3" );
460 ········}
461
462 ········private Reise CreateReise( string zweck )
463 ········{
464 ············Reise r = new Reise();
465 ············r.Zweck = zweck;
466 ············return r;
467 ········}
468
469 ········private Mitarbeiter CreateMitarbeiter()
470 ········{
471 ············Mitarbeiter m = new Mitarbeiter();
472 ············m.Nachname = "Kocher";
473 ············m.Vorname = "Hartmut";
474 ············return m;
475 ········}
476 ····}
477 }
478
New Commit (60cb179)
1 //
2 // Copyright (c) 2002-2016 Mirko Matytschak
3 // (www.netdataobjects.de)
4 //
5 // Author: Mirko Matytschak
6 //
7 // Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
8 // documentation files (the "Software"), to deal in the Software without restriction, including without limitation
9 // the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
10 // Software, and to permit persons to whom the Software is furnished to do so, subject to the following
11 // conditions:
12
13 // The above copyright notice and this permission notice shall be included in all copies or substantial portions
14 // of the Software.
15 //
16 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
17 // TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
19 // CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
20 // DEALINGS IN THE SOFTWARE.
21
22
23 using System;
24 using System.Collections;
25 using NUnit.Framework;
26 using NDO;
27 using Reisekosten;
28 using Reisekosten.Personal;
29
30 namespace NdoUnitTests
31 {
32 ····[TestFixture]
33 public class NDOReiseTests : NDOTest
34 ····{
35
36 ········public NDOReiseTests()
37 ········{
38 ········}
39
40 ········private PersistenceManager pm;
41 ········private Reise r;
42 ········private Mitarbeiter m;
43
44 ········[SetUp]
45 ········public void Setup()
46 ········{
47 ············pm = PmFactory.NewPersistenceManager();
48 ············r = CreateReise( "ADC" );
49 ············m = CreateMitarbeiter();
50 ········}
51
52 ········[TearDown]
53 ········public void TearDown()
54 ········{
55 ············try
56 ············{
57 ················pm.Abort();
58 ················IList mitarbeiterListe = pm.GetClassExtent( typeof( Mitarbeiter ), false );
59 ················//················Console.WriteLine("TearDown löscht " + mitarbeiterListe.Count + " Mitarbeiter");
60 ················pm.Delete( mitarbeiterListe );
61 ················pm.Save();
62 ················IList reiseListe = pm.GetClassExtent( typeof( Reise ), false );
63 ················//················Console.WriteLine("TearDown löscht " + reiseListe.Count + " Reisen");
64 ················pm.Delete( reiseListe );
65 ················pm.Save();
66 ················pm.Close();
67 ············}
68 ············catch (Exception ex)
69 ············{
70 ················System.Console.Error.WriteLine( "Exception in TearDown: " + ex );
71 ············}
72 ········}
73
74 ········[Test]
75 ········public void TestEmptyTransactionSave()
76 ········{
77 ············pm.Save();
78 ········}
79
80 ········[Test]
81 ········public void TestEmptyTransactionAbort()
82 ········{
83 ············pm.Abort();
84 ········}
85
86 ········[Test]
87 ········public void EmptyDB()
88 ········{
89 ············IList reiseListe = pm.GetClassExtent( typeof( Reise ), true );
90 ············pm.Delete( reiseListe );
91 ············pm.Save();
92 ············IList mitarbeiterListe = pm.GetClassExtent( typeof( Mitarbeiter ), true );
93 ············pm.Delete( mitarbeiterListe );
94 ············pm.Save();
95 ········}
96
97 ········[Test]
98 ········public void TestObjectCreation()
99 ········{
100 ············m.Hinzufuegen( r );
101 ············pm.MakePersistent( m );
102 ············Assert.That(r.NDOObjectId != null, "ObjectId should be valid" );
103 ············Assert.That(NDOObjectState.Created ==··r.NDOObjectState, "Status wrong" );
104 ········}
105
106 ········[Test]
107 ········public void TestObjectCreationSave()
108 ········{
109 ············m.Hinzufuegen( r );
110 ············pm.MakePersistent( m );
111 ············pm.Save();
112 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "Status wrong" );
113 ········}
114
115 ········[Test]
116 ········public void TestObjectCreationSaveChanged()
117 ········{
118 ············m.Hinzufuegen( r );
119 ············pm.MakePersistent( m );
120 ············r.Zweck = "Test";
121 ············pm.Save();
122 ············Assert.That("Test" ==··r.Zweck, "Zweck wrong" );
123 ········}
124
125 ········[Test]
126 ········public void TestObjectCreationAbort()
127 ········{
128 ············m.Hinzufuegen( r );
129 ············pm.MakePersistent( m );
130 ············pm.Abort();
131 ············Assert.That(r.NDOObjectId == null, "Transient object shouldn't have ID" );
132 ············Assert.That(((IPersistenceCapable)r).NDOStateManager == null, "Transient object shouldn't have state manager" );
133 ············Assert.That(NDOObjectState.Transient ==··r.NDOObjectState, "Status wrong" );
134 ········}
135
136 ········[Test]
137 ········public void TestObjectCreationAbortChanged()
138 ········{
139 ············m.Hinzufuegen( r );
140 ············pm.MakePersistent( m );
141 ············r.Zweck = "Möller";
142 ············pm.Abort();
143 ············Assert.That("ADC" ==··r.Zweck, "Nachname wrong" );
144 ········}
145
146 ········[Test]
147 ········public void TestObjectId()
148 ········{
149 ············m.Hinzufuegen( r );
150 ············pm.MakePersistent( m );
151 ············ObjectId id = r.NDOObjectId;
152 ············ObjectId id2 = new ObjectId( id );
153 ············Assert.That(r.NDOObjectId ==··id, "IDs should be equal" );
154 ············Assert.That(r.NDOObjectId ==··id2, "IDs should be equal" );
155 ············if (!pm.HasOwnerCreatedIds && r.NDOObjectId.Id[0] is Int32)
156 ················Assert.That( (int)id.Id[0] < 0, "Negative key in DS" );
157 ············pm.Save();
158 ············Assert.That(r.NDOObjectId ==··id, "IDs should be equal" );
159 ············Assert.That(r.NDOObjectId ==··id2, "IDs should be equal" );
160 ············if (!pm.HasOwnerCreatedIds && r.NDOObjectId.Id[0] is Int32)
161 ················Assert.That( (int)id.Id[0] > 0, "Positive key in DB" );
162 ········}
163
164 ········[Test]
165 ········public void TestCreateDeleteTransitionSave()
166 ········{
167 ············m.Hinzufuegen( r );
168 ············pm.MakePersistent( m );
169 ············pm.Delete( m );
170 ············Assert.That(r.NDOObjectId == null, "Transient object shouldn't have ID" );
171 ············Assert.That(((IPersistenceCapable)r).NDOStateManager == null, "Transient object shouldn't have state manager" );
172 ············Assert.That(NDOObjectState.Transient ==··r.NDOObjectState, "Status wrong" );
173 ············pm.Save();
174 ············Assert.That(r.NDOObjectId == null, "Transient object shouldn't have ID" );
175 ············Assert.That(((IPersistenceCapable)r).NDOStateManager == null, "Transient object shouldn't have state manager" );
176 ············Assert.That(NDOObjectState.Transient ==··r.NDOObjectState, "Status wrong" );
177 ········}
178
179 ········[Test]
180 ········public void TestCreateDeleteTransitionAbort()
181 ········{
182 ············m.Hinzufuegen( r );
183 ············pm.MakePersistent( m );
184 ············ObjectId id = m.NDOObjectId;
185 ············pm.Delete( m );
186 ············pm.Abort();
187 ············Assert.That(r.NDOObjectId == null, "Transient object shouldn't have ID" );
188 ············Assert.That(((IPersistenceCapable)r).NDOStateManager == null, "Transient object shouldn't have state manager" );
189 ············Assert.That(NDOObjectState.Transient ==··r.NDOObjectState, "Status wrong" );
190 ········}
191
192 ········[Test]
193 ········public void TestCleanupCache()
194 ········{
195 ············m.Hinzufuegen( r );
196 ············pm.MakePersistent( m );
197 ············pm.CleanupCache();
198 ············Assert.That(Object.ReferenceEquals(r, pm.FindObject( r.NDOObjectId )), "Getting same object twice should return same object" );
199 ············pm.Save();
200 ············pm.CleanupCache();
201 ············Assert.That(Object.ReferenceEquals(r, pm.FindObject( r.NDOObjectId )), "Getting same object twice should return same object" );
202 ············ObjectId id = r.NDOObjectId;
203 ············r = null;
204 ············pm.CleanupCache();
205 ············Assert.That(pm.FindObject( id ) != null, "Should find object" );
206 ········}
207
208 ········[Test]
209 ········public void TestUnloadCache()
210 ········{
211 ············m.Hinzufuegen( r );
212 ············pm.MakePersistent( m );
213 ············Assert.That(Object.ReferenceEquals(r, pm.FindObject( r.NDOObjectId )), "Getting same object twice should return same object" );
214 ············pm.Save();
215 ············pm.UnloadCache();
216 ············Assert.That( r != pm.FindObject( r.NDOObjectId ), "Getting same object twice should return different objects" );
217 ············ObjectId id = r.NDOObjectId;
218 ············r = null;
219 ············pm.UnloadCache();
220 ············Assert.That(pm.FindObject( id ) != null, "Should find object" );
221 ········}
222
223 ········[Test]
224 ········public void TestClassExtent()
225 ········{
226 ············ArrayList rliste = new ArrayList();
227 ············for (int i = 0; i < 100; i++)
228 ············{
229 ················Reise mr = CreateReise( "" + i );
230 ················m.Hinzufuegen( mr );
231 ················rliste.Add( mr );
232 ············}
233 ············pm.MakePersistent( m );
234
235 ············IList ReiseListe = pm.GetClassExtent( typeof( Reise ) );
236 ············Assert.That(0 ==··ReiseListe.Count, "Current extent should be empty" );
237 ············pm.Save();
238
239 ············ReiseListe = pm.GetClassExtent( typeof( Reise ) );
240 ············Assert.That(100 ==··ReiseListe.Count, "Number of read objects is wrong" );
241 ············// Check that all objects come from cache...
242 ············foreach (Reise m1 in ReiseListe)
243 ············{
244 ················Assert.That(NDOObjectState.Persistent ==··m1.NDOObjectState, "Wrong state" );
245 ············}
246
247 ············rliste.Clear();
248 ············rliste = null;
249 ············ReiseListe.Clear();
250 ············ReiseListe = null;
251 ············//pm.CleanupCache();
252 ············pm.UnloadCache();
253 ············ReiseListe = pm.GetClassExtent( typeof( Reise ) );
254 ············Assert.That(100 ==··ReiseListe.Count, "Number of read objects is wrong" );
255 ············// Check that all objects are reloaded
256 ············foreach (Reise m1 in ReiseListe)
257 ············{
258 ················Assert.That(NDOObjectState.Hollow ==··m1.NDOObjectState, "Wrong state" );
259 ············}
260 ········}
261
262 ········[Test]
263 ········public void TestDeleteHollow()
264 ········{
265 ············m.Hinzufuegen( r );
266 ············pm.MakePersistent( m );
267 ············pm.Save();
268 ············pm.UnloadCache();
269 ············r = (Reise)pm.FindObject( r.NDOObjectId );
270 ············Assert.That(NDOObjectState.Hollow ==··r.NDOObjectState, "Wrong state #1" );
271 ············pm.Delete( r );
272 ············Assert.That(NDOObjectState.Deleted ==··r.NDOObjectState, "Wrong state #2" );
273 ············pm.Abort();
274 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "Wrong state #3" );
275 ············pm.UnloadCache();
276 ············r = (Reise)pm.FindObject( r.NDOObjectId );
277 ············Assert.That(NDOObjectState.Hollow ==··r.NDOObjectState, "Wrong state #4" );
278 ············pm.Delete( r );
279 ············pm.Save();
280 ············Assert.That(NDOObjectState.Transient ==··r.NDOObjectState, "Wrong state #5" );
281
282 ············IList l = pm.GetClassExtent( typeof( Reise ) );
283 ············Assert.That(0 ==··l.Count, "Number of read objects is wrong" );
284 ········}
285
286 ········[Test]
287 ········public void TestDeletePersistent()
288 ········{
289 ············m.Hinzufuegen( r );
290 ············pm.MakePersistent( m );
291 ············pm.Save();
292 ············pm.Delete( r );
293 ············Assert.That(NDOObjectState.Deleted ==··r.NDOObjectState, "Wrong state #1" );
294 ············IList l = pm.GetClassExtent( typeof( Reise ) );
295 ············Assert.That(1 ==··l.Count, "Number of read objects is wrong" );
296 ············pm.Save();
297 ············l = pm.GetClassExtent( typeof( Reise ) );
298 ············Assert.That(0 ==··l.Count, "Number of read objects is wrong" );
299 ············pm.MakeHollow( m );··// Reread during TearDown will not load Reise anymore.
300 ········}
301
302 ········[Test]
303 ········public void TestDeletePersistentDirty()
304 ········{
305 ············m.Hinzufuegen( r );
306 ············pm.MakePersistent( m );
307 ············pm.Save();
308 ············r.Zweck = "Test";
309 ············Assert.That(NDOObjectState.PersistentDirty ==··r.NDOObjectState, "Wrong state #1" );
310 ············pm.Delete( r );
311 ············Assert.That(NDOObjectState.Deleted ==··r.NDOObjectState, "Wrong state #1" );
312 ············pm.Abort();
313 ············Assert.That("ADC" ==··r.Zweck, "Name shouldn't be changed" );
314 ············pm.Delete( r );
315 ············pm.Save();
316 ············IList l = pm.GetClassExtent( typeof( Reise ) );
317 ············Assert.That(0 ==··l.Count, "Number of read objects is wrong" );
318 ············pm.MakeHollow( m );··// Reread during TearDown will not load Reise anymore.
319 ········}
320
321 ········[Test]
322 ········public void TestPersistentDirty()
323 ········{
324 ············m.Hinzufuegen( r );
325 ············pm.MakePersistent( m );
326 ············pm.Save();
327 ············r.Zweck = "Test";
328 ············Assert.That(NDOObjectState.PersistentDirty ==··r.NDOObjectState, "Wrong state #1" );
329 ············pm.Abort();
330 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "Wrong state #2" );
331 ············Assert.That("ADC" ==··r.Zweck, "Name shouldn't be changed" );
332 ········}
333
334 ········[Test]
335 ········public void TestMakeTransient()
336 ········{
337 ············m.Hinzufuegen( r );
338 ············pm.MakePersistent( m );
339 ············pm.Save();
340 ············ObjectId id = r.NDOObjectId;
341 ············pm.MakeTransient( r );
342 ············Assert.That(((IPersistenceCapable)r).NDOStateManager == null, "Transient object shouldn't have state manager" );
343 ············Assert.That(NDOObjectState.Transient ==··r.NDOObjectState, "Wrong state #1" );
344 ············Assert.That( id.IsValid(), "Id should still be valid #1" );
345 ············r = (Reise)pm.FindObject( id );
346 ············Assert.That(NDOObjectState.Hollow ==··r.NDOObjectState, "Wrong state #2" );
347 ············pm.MakeTransient( r );
348 ············Assert.That(((IPersistenceCapable)r).NDOStateManager == null, "Transient object shouldn't have state manager" );
349 ············Assert.That(NDOObjectState.Transient ==··r.NDOObjectState, "Wrong state #3" );
350 ············Assert.That( id.IsValid(), "Id should still be valid #2" );
351 ············r = (Reise)pm.FindObject( id );
352 ············pm.Delete( r );
353 ············pm.Save();
354 ············pm.MakeHollow( m );··// Reread during TearDown will not load Reise anymore.
355 ········}
356
357 ········[Test]
358 ········public void TestMakeHollow()
359 ········{
360 ············m.Hinzufuegen( r );
361 ············pm.MakePersistent( m );
362 ············pm.Save();
363 ············pm.MakeHollow( r );
364 ············Assert.That(NDOObjectState.Hollow ==··r.NDOObjectState, "Wrong state #1" );
365 ············string access = r.Zweck;
366 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "Wrong state #2" );
367 ············pm.MakeAllHollow();
368 ············Assert.That(NDOObjectState.Hollow ==··r.NDOObjectState, "Wrong state #3" );
369 ········}
370
371 ········[Test]
372 ········public void TestChangeHollow()
373 ········{
374 ············m.Hinzufuegen( r );
375 ············pm.MakePersistent( m );
376 ············pm.Save();
377 ············pm.MakeHollow( r );
378 ············r.Zweck = "Test";
379 ············pm.Abort();
380 ············Assert.That("ADC" ==··r.Zweck, "Name shouldn't be changed" );
381 ············pm.MakeHollow( r );
382 ············r.Zweck = "Test";
383 ············pm.Save();
384 ············Assert.That("Test" ==··r.Zweck, "Name should be changed" );
385 ········}
386
387 ········[Test]
388 ········public void TestRelatedObject()
389 ········{
390 ············m.Hinzufuegen( r );
391 ············pm.MakePersistent( m );
392 ············pm.Save();
393 ············pm.MakeHollow( r );
394 ············r.Zweck = "Test";
395 ············pm.Save();··// Bug would overwrite foreign key in database.
396 ············Assert.That("Test" ==··r.Zweck, "Name should be changed" );
397 ············r = null;
398 ············ObjectId id = m.NDOObjectId;
399 ············m = null;
400 ············pm.UnloadCache();
401 ············m = (Mitarbeiter)pm.FindObject( id );
402 ············Assert.That(1 ==··m.Reisen.Count, "Number of children" );
403 ········}
404
405 ········[Test]
406 ········public void TestRefreshFailed()
407 ········{
408 ············var thrown = false;
409 ············try
410 ············{
411 ················pm.Refresh( r );
412 ············}
413 ············catch (NDOException)
414 ············{
415 ················thrown = true;
416 ············}
417 ············Assert.That(true ==··thrown );
418 ········}
419
420 ········[Test]
421 ········public void TestRefresh()
422 ········{
423 ············m.Hinzufuegen( r );
424 ············pm.MakePersistent( m );
425 ············pm.Save();
426 ············pm.MakeHollow( r );
427 ············pm.Refresh( r );
428 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "Wrong state #1" );
429 ············pm.Refresh( r );
430 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "Wrong state #2" );
431 ············ObjectId id = r.NDOObjectId;
432
433 ············PersistenceManager pm2 = PmFactory.NewPersistenceManager();
434 ············Reise m2 = (Reise)pm2.FindObject( id );
435 ············Assert.That(m2 != null, "Cannot load object" );
436 ············m2.Zweck = "Test";
437 ············pm2.Save();
438 ············pm2.Close();
439
440 ············Assert.That("ADC" ==··r.Zweck, "Wrong name #1" );
441 ············Assert.That("Test" ==··m2.Zweck, "Wrong name #2" );
442 ············pm.Refresh( r );
443 ············Assert.That("Test" ==··r.Zweck, "Wrong name #3" );
444 ········}
445
446 ········[Test]
447 ········public void TestHollowMode()
448 ········{
449 ············m.Hinzufuegen( r );
450 ············pm.MakePersistent( m );
451 ············pm.HollowMode = true;
452 ············pm.Save();
453 ············Assert.That(NDOObjectState.Hollow ==··r.NDOObjectState, "Wrong state #1" );
454 ············r.Zweck = "Test";
455 ············pm.Abort();
456 ············Assert.That(NDOObjectState.Hollow ==··r.NDOObjectState, "Wrong state #2" );
457 ············r.Zweck = "Test";
458 ············pm.Save();
459 ············Assert.That(NDOObjectState.Hollow ==··r.NDOObjectState, "Wrong state #3" );
460 ········}
461
462 ········private Reise CreateReise( string zweck )
463 ········{
464 ············Reise r = new Reise();
465 ············r.Zweck = zweck;
466 ············return r;
467 ········}
468
469 ········private Mitarbeiter CreateMitarbeiter()
470 ········{
471 ············Mitarbeiter m = new Mitarbeiter();
472 ············m.Nachname = "Kocher";
473 ············m.Vorname = "Hartmut";
474 ············return m;
475 ········}
476 ····}
477 }
478