Datei: IntegrationTests/IntegrationTests/NDOReiseLänderTests.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.Diagnostics;
25 using System.Collections;
26 using NUnit.Framework;
27 using NDO;
28 using NDO.Query;
29 using Reisekosten;
30 using Reisekosten.Personal;
31
32 namespace NdoUnitTests {
33 ····[TestFixture]
34 public class NDOReiseLänderTests {
 
35
36 ········public NDOReiseLänderTests() {
37 ········}
38
39 ········private PersistenceManager pm;
40 ········private Reise r;
41 ········private Mitarbeiter m;
42 ········private Land usa;
43 ········private Land de;
44
45 ········[SetUp]
46 ········public void Setup() {
47 ············pm = PmFactory.NewPersistenceManager();
48 ············r = CreateReise("ADC");
49 ············m = CreateMitarbeiter();
50 ············m.Hinzufuegen(r);
51 ············pm.MakePersistent(m);
52 ········}
53
54 ········[TearDown]
55 ········public void TearDown() {
56 ············try {
57 ················pm = PmFactory.NewPersistenceManager();
58 ················pm.TransactionMode = TransactionMode.None;
59
60 ················IList mitarbeiterListe = pm.GetClassExtent( typeof( Mitarbeiter ), false );
61 ················pm.Delete( mitarbeiterListe );
62 ················pm.Save();
63 ················using (var handler = pm.GetSqlPassThroughHandler())
64 ················{
65 ····················var sql = $"DELETE FROM {pm.NDOMapping.FindClass( typeof( Reise ) ).TableName}";
66 ····················handler.Execute( sql );
67 ····················sql = $"DELETE FROM {pm.NDOMapping.FindClass( typeof( Mitarbeiter ) ).TableName}";
68 ····················handler.Execute( sql );
69 ····················sql = $"DELETE FROM {pm.NDOMapping.FindClass( typeof( Land ) ).TableName}";
70 ····················handler.Execute( sql );
71 ················}
72 ············}
73 ············catch (Exception ex) {
74 ················System.Diagnostics.Debug.WriteLine("Exception in TearDown: " + ex);
75 ············}
76 ········}
77
78
79 ········[Test]
80 ········public void EmptyDB() {
81 ············IList mitarbeiterListe = pm.GetClassExtent(typeof(Mitarbeiter), false);
82 ············pm.Delete(mitarbeiterListe);
83 ············pm.Save();
84 ············/*
85 ············IList reiseListe = pm.GetClassExtent(typeof(Reise), true);
86 ············pm.Delete(reiseListe);
87 ············pm.Save();
88 ············IList mitarbeiterListe = pm.GetClassExtent(typeof(Mitarbeiter), true);
89 ············pm.Delete(mitarbeiterListe);
90 ············pm.Save();
91 ············ * */
92 ········}
93
94 ········[Test]
95 ········public void TestObjectCreationTransient()
96 ········{
97 ············bool thrown = false;
98 ············try
99 ············{
100 ················r.LandHinzufügen( new Land( "USA" ) );
101 ············}
102 ············catch (Exception ex)
103 ············{
104 ················thrown = true;
105 ············}
106 ············Assert.That(true ==··thrown );
107 ········}
108
109 ········[Test]
110 ········public void TestObjectCreation() {
111 ············CreateLänder();
112 ············r.LandHinzufügen(de);
113 ············Assert.That(1 ==··r.Länder.Count, "Number of Länder");
114 ············Assert.That(NDOObjectState.Created ==··r.NDOObjectState, "Status wrong");
115 ············Land l = (Land)r.Länder[0];
116 ············Assert.That(NDOObjectState.Created ==··l.NDOObjectState, "Status wrong");
117 ········}
118
119 ········[Test]
120 ········public void TestObjectCreationSave() {
121 ············CreateLänder();
122 ············r.LandHinzufügen(de);
123 ············pm.Save();
124 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "Status wrong");
125 ············Assert.That(NDOObjectState.Persistent ==··de.NDOObjectState, "Status wrong");
126 ············Assert.That(NDOObjectState.Persistent ==··usa.NDOObjectState, "Status wrong");
127 ············Assert.That(1 ==··r.Länder.Count, "Number of Länder");
128 ········}
129
130 ········[Test]
131 ········public void TestObjectCreationSaveMultiple() {
132 ············CreateLänder();
133 ············r.LandHinzufügen(de);
134 ············r.LandHinzufügen(usa);
135 ············pm.Save();
136 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "Status wrong");
137 ············Assert.That(NDOObjectState.Persistent ==··de.NDOObjectState, "Status wrong");
138 ············Assert.That(NDOObjectState.Persistent ==··usa.NDOObjectState, "Status wrong");
139 ············Assert.That(2 ==··r.Länder.Count, "Number of Länder");
140 ········}
141
142
143 ········[Test]
144 ········public void AssoTestAggregateFunction()
145 ········{
146 ············CreateLänder();
147 ············r.LandHinzufügen(usa);
148 ············pm.Save();
149 ············ObjectId oid = usa.NDOObjectId;
150 ············pm.UnloadCache();
151 ············NDOQuery<Reise> q = new NDOQuery<Reise>(pm, "dieLaender.oid = {0}");
152 ············q.Parameters.Add(oid.Id[0]);
153 ············decimal count = (decimal) q.ExecuteAggregate("*", AggregateType.Count);
154 ············Assert.That(count > 0m, "Count should be > 0");
155 ············usa = (Land) pm.FindObject(oid);
156 ············Assert.That(usa != null, "USA nicht gefunden");
157 ············r.LandLöschen(usa.Name);
158 ············pm.Save();
159 ············pm.UnloadCache();
160 ············count = (decimal) q.ExecuteAggregate("*", AggregateType.Count);
161 ············Assert.That(0m ==··count, "Count should be 0");
162 ········}
163
164 ········[Test]
165 ········public void TestObjectCreationSaveChanged() {
166 ············CreateLänder();
167 ············r.LandHinzufügen(de);
168 ············de.Name = "Deutschland";
169 ············pm.Save();
170 ············Assert.That("Deutschland" ==··de.Name, "Name wrong");
171 ········}
172
173 ········[Test]
174 ········public void TestObjectCreationLandSavedFirst() {
175 ············CreateLänder();
176 ············pm.Save();
177 ············r.LandHinzufügen(de);
178 ············de.Name = "Deutschland";
179 ············pm.Save();
180 ············Assert.That("Deutschland" ==··de.Name, "Name wrong");
181 ············Assert.That(1 ==··r.Länder.Count, "Number of Länder");
182 ········}
183
184 ········[Test]
185 ········public void TestObjectCreationAbort() {
186 ············CreateLänder();
187 ············r.LandHinzufügen(de);
188 ············pm.Abort();
189 ············Assert.That(de.NDOObjectId == null, "Transient object shouldn't have ID");
190 ············Assert.That(((IPersistenceCapable)de).NDOStateManager == null, "Transient object shouldn't have state manager");
191 ············Assert.That(NDOObjectState.Transient ==··de.NDOObjectState, "Status wrong");
192 ········}
193
194 ········[Test]
195 ········public void TestCreateDeleteTransitionSave() {
196 ············CreateLänder();
197 ············r.LandHinzufügen(de);
198 ············m.LöscheReisen();
199 ············Assert.That(NDOObjectState.Transient ==··r.NDOObjectState, "Reise should be transient");
200 ············Assert.That(r.NDOObjectId == null, "Transient object shouldn't have ID");
201 ············Assert.That(((IPersistenceCapable)r).NDOStateManager == null, "Transient object shouldn't have state manager");
202 ············Assert.That(NDOObjectState.Transient ==··r.NDOObjectState, "Status wrong");
203 ············pm.Save();
204 ············Assert.That(r.NDOObjectId == null, "Transient object shouldn't have ID");
205 ············Assert.That(((IPersistenceCapable)r).NDOStateManager == null, "Transient object shouldn't have state manager");
206 ············Assert.That(NDOObjectState.Transient ==··r.NDOObjectState, "Status wrong");
207 ········}
208
209 ········[Test]
210 ········public void TestRelatedDelete()
211 ········{
212 ············CreateLänder();
213 ············r.LandHinzufügen(de);
214 ············pm.Save();
215 ············Assert.That(1 ==··de.DieReisen.Count, "The Reise should still be in the container");
216 ············pm.Delete(m);
217 ············pm.Save();
218 //············Assert.That(1 ==··de.DieReisen.Count, "The Reise should still be in the container");
219 //············Assert.That(NDOObjectState.Transient ==··((IPersistenceCapable)de.DieReisen[0]).NDOObjectState, "Wrong object state");
220
221 ············//pm.MakeHollow(de);
222 ············IList l = pm.GetClassExtent(typeof(Reise), true);
223 ············Assert.That(0 ==··l.Count, "l should be empty");
224 ············l = pm.GetClassExtent(typeof(Land), true);
225 ············foreach(Land land in l)
226 ············{
227 ················string z;
228 ················if (land.DieReisen.Count > 0)
229 ····················z = ((Reise)land.DieReisen[0]).Zweck;
230 ················Assert.That(0 ==··land.DieReisen.Count, "DieReisen should be empty");
231 ············}
232 ········}
233
234 ········[Test]
235 ········public void TestUnloadCache() {
236 ············CreateLänder();
237 ············r.LandHinzufügen(de);
238 ············//pm.UnloadCache();
239 ············Assert.That(Object.ReferenceEquals(de, pm.FindObject(((Land)r.Länder[0]).NDOObjectId)), "Getting same object twice should return same object");
240 ············pm.Save();
241 ············pm.UnloadCache();
242 ············pm.MakeHollow(r);
243 ············Assert.That(1 ==··r.Länder.Count, "Number of Länder");
244 ············Land l = (Land)r.Länder[0];
245 ············Assert.That(l != de, "Getting same object twice should return different objects");
246 ············Assert.That(de.Name ==··l.Name, "Name should be same");
247 ············ObjectId id = l.NDOObjectId;
248 ············l = null;
249 ············pm.UnloadCache();
250 ············Assert.That(pm.FindObject(id) != null, "Should find object");
251 ············pm.UnloadCache();
252 ············Assert.That(1 ==··r.Länder.Count, "Number of Länder");
253 ········}
254
255 ········[Test]
256 ········public void TestMakeTransient() {
257 ············CreateLänder();
258 ············r.LandHinzufügen(de);
259 ············pm.Save();
260 ············ObjectId id = r.NDOObjectId;
261 ············pm.MakeTransient(r);
262 ············Assert.That(((IPersistenceCapable)r).NDOStateManager == null, "Transient object shouldn't have state manager");
263 ············Assert.That(NDOObjectState.Transient ==··r.NDOObjectState, "Wrong state #1");
264 ············Assert.That(id.IsValid(), "Id should still be valid #1");
265 ············pm.Save();
266 ············Land l = (Land)r.Länder[0];
267 ············Assert.That(de.Name ==··l.Name, "Name is wrong");
268 ············Assert.That(Object.ReferenceEquals(de, l), "Land is wrong");
269 ············pm.MakeHollow(m);··// make sure, Reise is loaded fresh during TearDown
270 ········}
271
272 ········[Test]
273 ········public void TestMakeTransientMitarbeiterDeleteFails() {
274 ············CreateLänder();
275 ············r.LandHinzufügen(de);
276 ············pm.Save();
277 ············pm.MakeTransient(r);
278 ············try {
279 ················pm.Delete(m);
280 ················Assert.Fail("Mitarbeiter shouldn't be deletable because Reise is Transient");
281 ············} catch (NDOException) {
282 ············}
283 ············//((Reise)m.Reisen[0]).NDOObjectState = NDOObjectState.Persistent;
284 ········}
285
286
287 ········[Test]
288 ········public void TestDeleteLand() {
289 ············CreateLänder();
290 ············r.LandHinzufügen(de);
291 ············r.LandLöschen(de.Name);
292 ············pm.Save();
293 ············Assert.That(0 ==··r.Länder.Count, "#1 Number of Länder");
294 ············pm.MakeHollow(r);
295 ············Assert.That(0 ==··r.Länder.Count, "#2 Number of Länder");
296 ········}
297
298 ········[Test]
299 ········public void TestDeleteLänder() {
300 ············CreateLänder();
301 ············r.LandHinzufügen(de);
302 ············r.LandHinzufügen(usa);
303 ············r.LandLöschen(de.Name);
304 ············Assert.That(1 ==··r.Länder.Count, "#1 Number of Länder");
305 ············pm.Save();
306 ············Assert.That(Object.ReferenceEquals(usa, r.Länder[0]), "Land is wrong");
307 ············Assert.That(1 ==··r.Länder.Count, "#2 Number of Länder");
308 ············pm.MakeHollow(r);
309 ············Assert.That(1 ==··r.Länder.Count, "#3 Number of Länder");
310 ········}
311
312 ········[Test]
313 ········public void TestDeleteReise() {
314 ············CreateLänder();
315 ············r.LandHinzufügen(de);
316 ············r.LandHinzufügen(usa);
317 ············m.LöscheReisen();
318 ············Assert.That(2 ==··r.Länder.Count, "#1 Number of Länder");
319 ············pm.Save();
320 ············Assert.That(2 ==··r.Länder.Count, "#2 Number of Länder");
321 ········}
322
323 ········[Test]
324 ········public void TestDeleteReiseSave()
325 ········{
326 ············CreateLänder();
327 ············r.LandHinzufügen(de);
328 ············r.LandHinzufügen(usa);
329 ············Assert.That(1 ==··usa.DieReisen.Count, "#1 Number of Reisen");
330 ············Assert.That(1 ==··de.DieReisen.Count, "#2 Number of Reisen");
331 ············pm.Save();
332 ············pm.UnloadCache();
333 ············m.LöscheReisen();
334 ············Assert.That(2 ==··r.Länder.Count, "#1 Number of Länder");
335 ············pm.Save();
336 ············Assert.That(2 ==··r.Länder.Count, "#2 Number of Länder");
337 ············pm.UnloadCache();
338 ············IQuery q = new NDOQuery<Land>(pm, "name LIKE 'D%'");
339 ············IList list = q.Execute();
340 ············Assert.That(1 ==··list.Count, "#3 Number of Länder");
341 ············de = (Land) list[0];
342 ············Assert.That(0 ==··de.DieReisen.Count, "#3 Number of Reisen");
343 ········}
344
345
346 ········[Test]
347 ········public void TestDeleteLänderSave() {
348 ············CreateLänder();
349 ············r.LandHinzufügen(de);
350 ············r.LandHinzufügen(usa);
351 ············pm.Save();
352 ············r.LandLöschen(de.Name);
353 ············pm.Save();
354 ············Assert.That(1 ==··r.Länder.Count, "#1 Number of Länder");
355 ············pm.MakeHollow(r);
356 ············Assert.That(1 ==··r.Länder.Count, "#2 Number of Länder");
357 ········}
358
359 ········[Test]
360 ········public void TestDeleteLänderAbort() {
361 ············CreateLänder();
362 ············r.LandHinzufügen(de);
363 ············r.LandHinzufügen(usa);
364 ············pm.Save();
365 ············r.LandLöschen(de.Name);
366 ············pm.Abort();
367 ············Assert.That(2 ==··r.Länder.Count, "#1 Number of Länder");
368 ············pm.MakeHollow(r);
369 ············Assert.That(2 ==··r.Länder.Count, "#2 Number of Länder");
370 ········}
371
372 ········[Test]
373 ········public void TestMakeHollow() {
374 ············CreateLänder();
375 ············r.LandHinzufügen(de);
376 ············pm.Save();
377 ············pm.MakeHollow(r);
378 ············Assert.That(NDOObjectState.Hollow ==··r.NDOObjectState, "Wrong state #1");
379 ············Land l = (Land)r.Länder[0];
380 ············// Should be in Cache
381 ············Assert.That(NDOObjectState.Persistent ==··l.NDOObjectState, "Wrong state #2");
382 ············Assert.That(de.Name ==··l.Name, "Name is wrong");
383 ············Assert.That(Object.ReferenceEquals(de, l), "Land is wrong");
384 ············Assert.That(1 ==··r.Länder.Count, "#1 Number of Länder");
385 ········}
386
387
388 ········[Test]
389 ········public void TestRefresh() {
390 ············CreateLänder();
391 ············r.LandHinzufügen(de);
392 ············pm.Save();
393 ············pm.MakeHollow(r);
394 ············pm.Refresh(r);
395 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "Wrong state #1");
396 ········}
397
398 ········[Test]
399 ········public void TestJoinQuery()
400 ········{
401 ············CreateLänder();
402 ············r.LandHinzufügen(de);
403 ············r.LandHinzufügen(usa);
404
405 ············Reise r2 = CreateReise("ADW");
406 ············r2.LandHinzufügen(de);
407 ············m.Hinzufuegen(r2);
408 ············
409
410 ············pm.Save();
411
412 ············NDOQuery<Reise> q = new NDOQuery<Reise>(pm, "dieLaender.name = {0}");
413 ············q.Parameters.Add( usa.Name );
414 ············IList l = q.Execute();
415 ············Assert.That(1 ==··l.Count, "Wrong number of travels");
416 ········}
417
418 ········[Test]
419 ········public void TestIntermediateTableDelete()
420 ········{
421 ············CreateLänder();
422 ············pm.Save();
423 ············r.LandHinzufügen(de);
424 ············r.LandHinzufügen(usa);
425 ············pm.Save();
426 ············r.LandLöschen(de);
427 ············pm.Delete(de);
428 ············pm.Save();
429 ········}
430
431 ········private Reise CreateReise(string zweck)
432 ········{
433 ············Reise r = new Reise();····
434 ············r.Zweck = zweck;
435 ············return r;
436 ········}
437
438 ········private Mitarbeiter CreateMitarbeiter() {
439 ············Mitarbeiter m = new Mitarbeiter();
440 ············m.Nachname··= "Kocher";
441 ············m.Vorname = "Hartmut";
442 ············return m;
443 ········}
444
445 ········private void CreateLänder() {
446 ············usa = new Land("US");
447 ············pm.MakePersistent(usa);
448 ············de = new Land("DE");
449 ············pm.MakePersistent(de);
450 ········}
451 ····}
452 }
453
454
New Commit (60cb179)
1 //
2 // Copyright ( c) 2002-2023 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.Query;
29 using Reisekosten;
30 using Reisekosten.Personal;
31
32 namespace NdoUnitTests {
33 ····[TestFixture]
34 public class NDOReiseLänderTests : NDOTest
35 ····{
36
37 ········public NDOReiseLänderTests() {
38 ········}
39
40 ········private PersistenceManager pm;
41 ········private Reise r;
42 ········private Mitarbeiter m;
43 ········private Land usa;
44 ········private Land de;
45
46 ········[SetUp]
47 ········public void Setup() {
48 ············pm = PmFactory.NewPersistenceManager();
49 ············r = CreateReise("ADC");
50 ············m = CreateMitarbeiter();
51 ············m.Hinzufuegen(r);
52 ············pm.MakePersistent(m);
53 ········}
54
55 ········[TearDown]
56 ········public void TearDown() {
57 ············try {
58 ················pm = PmFactory.NewPersistenceManager();
59 ················pm.TransactionMode = TransactionMode.None;
60
61 ················IList mitarbeiterListe = pm.GetClassExtent( typeof( Mitarbeiter ), false );
62 ················pm.Delete( mitarbeiterListe );
63 ················pm.Save();
64 ················using (var handler = pm.GetSqlPassThroughHandler())
65 ················{
66 ····················var sql = $"DELETE FROM {pm.NDOMapping.FindClass( typeof( Reise ) ).TableName}";
67 ····················handler.Execute( sql );
68 ····················sql = $"DELETE FROM {pm.NDOMapping.FindClass( typeof( Mitarbeiter ) ).TableName}";
69 ····················handler.Execute( sql );
70 ····················sql = $"DELETE FROM {pm.NDOMapping.FindClass( typeof( Land ) ).TableName}";
71 ····················handler.Execute( sql );
72 ················}
73 ············}
74 ············catch (Exception ex) {
75 ················System.Diagnostics.Debug.WriteLine("Exception in TearDown: " + ex);
76 ············}
77 ········}
78
79
80 ········[Test]
81 ········public void EmptyDB() {
82 ············IList mitarbeiterListe = pm.GetClassExtent(typeof(Mitarbeiter), false);
83 ············pm.Delete(mitarbeiterListe);
84 ············pm.Save();
85 ············/*
86 ············IList reiseListe = pm.GetClassExtent(typeof(Reise), true);
87 ············pm.Delete(reiseListe);
88 ············pm.Save();
89 ············IList mitarbeiterListe = pm.GetClassExtent(typeof(Mitarbeiter), true);
90 ············pm.Delete(mitarbeiterListe);
91 ············pm.Save();
92 ············ * */
93 ········}
94
95 ········[Test]
96 ········public void TestObjectCreationTransient()
97 ········{
98 ············bool thrown = false;
99 ············try
100 ············{
101 ················r.LandHinzufügen( new Land( "USA" ) );
102 ············}
103 ············catch (Exception ex)
104 ············{
105 ················thrown = true;
106 ············}
107 ············Assert.That(true ==··thrown );
108 ········}
109
110 ········[Test]
111 ········public void TestObjectCreation() {
112 ············CreateLänder();
113 ············r.LandHinzufügen(de);
114 ············Assert.That(1 ==··r.Länder.Count, "Number of Länder");
115 ············Assert.That(NDOObjectState.Created ==··r.NDOObjectState, "Status wrong");
116 ············Land l = (Land)r.Länder[0];
117 ············Assert.That(NDOObjectState.Created ==··l.NDOObjectState, "Status wrong");
118 ········}
119
120 ········[Test]
121 ········public void TestObjectCreationSave() {
122 ············CreateLänder();
123 ············r.LandHinzufügen(de);
124 ············pm.Save();
125 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "Status wrong");
126 ············Assert.That(NDOObjectState.Persistent ==··de.NDOObjectState, "Status wrong");
127 ············Assert.That(NDOObjectState.Persistent ==··usa.NDOObjectState, "Status wrong");
128 ············Assert.That(1 ==··r.Länder.Count, "Number of Länder");
129 ········}
130
131 ········[Test]
132 ········public void TestObjectCreationSaveMultiple() {
133 ············CreateLänder();
134 ············r.LandHinzufügen(de);
135 ············r.LandHinzufügen(usa);
136 ············pm.Save();
137 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "Status wrong");
138 ············Assert.That(NDOObjectState.Persistent ==··de.NDOObjectState, "Status wrong");
139 ············Assert.That(NDOObjectState.Persistent ==··usa.NDOObjectState, "Status wrong");
140 ············Assert.That(2 ==··r.Länder.Count, "Number of Länder");
141 ········}
142
143
144 ········[Test]
145 ········public void AssoTestAggregateFunction()
146 ········{
147 ············CreateLänder();
148 ············r.LandHinzufügen(usa);
149 ············pm.Save();
150 ············ObjectId oid = usa.NDOObjectId;
151 ············pm.UnloadCache();
152 ············NDOQuery<Reise> q = new NDOQuery<Reise>(pm, "dieLaender.oid = {0}");
153 ············q.Parameters.Add(oid.Id[0]);
154 ············decimal count = (decimal) q.ExecuteAggregate("*", AggregateType.Count);
155 ············Assert.That(count > 0m, "Count should be > 0");
156 ············usa = (Land) pm.FindObject(oid);
157 ············Assert.That(usa != null, "USA nicht gefunden");
158 ············r.LandLöschen(usa.Name);
159 ············pm.Save();
160 ············pm.UnloadCache();
161 ············count = (decimal) q.ExecuteAggregate("*", AggregateType.Count);
162 ············Assert.That(0m ==··count, "Count should be 0");
163 ········}
164
165 ········[Test]
166 ········public void TestObjectCreationSaveChanged() {
167 ············CreateLänder();
168 ············r.LandHinzufügen(de);
169 ············de.Name = "Deutschland";
170 ············pm.Save();
171 ············Assert.That("Deutschland" ==··de.Name, "Name wrong");
172 ········}
173
174 ········[Test]
175 ········public void TestObjectCreationLandSavedFirst() {
176 ············CreateLänder();
177 ············pm.Save();
178 ············r.LandHinzufügen(de);
179 ············de.Name = "Deutschland";
180 ············pm.Save();
181 ············Assert.That("Deutschland" ==··de.Name, "Name wrong");
182 ············Assert.That(1 ==··r.Länder.Count, "Number of Länder");
183 ········}
184
185 ········[Test]
186 ········public void TestObjectCreationAbort() {
187 ············CreateLänder();
188 ············r.LandHinzufügen(de);
189 ············pm.Abort();
190 ············Assert.That(de.NDOObjectId == null, "Transient object shouldn't have ID");
191 ············Assert.That(((IPersistenceCapable)de).NDOStateManager == null, "Transient object shouldn't have state manager");
192 ············Assert.That(NDOObjectState.Transient ==··de.NDOObjectState, "Status wrong");
193 ········}
194
195 ········[Test]
196 ········public void TestCreateDeleteTransitionSave() {
197 ············CreateLänder();
198 ············r.LandHinzufügen(de);
199 ············m.LöscheReisen();
200 ············Assert.That(NDOObjectState.Transient ==··r.NDOObjectState, "Reise should be transient");
201 ············Assert.That(r.NDOObjectId == null, "Transient object shouldn't have ID");
202 ············Assert.That(((IPersistenceCapable)r).NDOStateManager == null, "Transient object shouldn't have state manager");
203 ············Assert.That(NDOObjectState.Transient ==··r.NDOObjectState, "Status wrong");
204 ············pm.Save();
205 ············Assert.That(r.NDOObjectId == null, "Transient object shouldn't have ID");
206 ············Assert.That(((IPersistenceCapable)r).NDOStateManager == null, "Transient object shouldn't have state manager");
207 ············Assert.That(NDOObjectState.Transient ==··r.NDOObjectState, "Status wrong");
208 ········}
209
210 ········[Test]
211 ········public void TestRelatedDelete()
212 ········{
213 ············CreateLänder();
214 ············r.LandHinzufügen(de);
215 ············pm.Save();
216 ············Assert.That(1 ==··de.DieReisen.Count, "The Reise should still be in the container");
217 ············pm.Delete(m);
218 ············pm.Save();
219 //············Assert.That(1 ==··de.DieReisen.Count, "The Reise should still be in the container");
220 //············Assert.That(NDOObjectState.Transient ==··((IPersistenceCapable)de.DieReisen[0]).NDOObjectState, "Wrong object state");
221
222 ············//pm.MakeHollow(de);
223 ············IList l = pm.GetClassExtent(typeof(Reise), true);
224 ············Assert.That(0 ==··l.Count, "l should be empty");
225 ············l = pm.GetClassExtent(typeof(Land), true);
226 ············foreach(Land land in l)
227 ············{
228 ················string z;
229 ················if (land.DieReisen.Count > 0)
230 ····················z = ((Reise)land.DieReisen[0]).Zweck;
231 ················Assert.That(0 ==··land.DieReisen.Count, "DieReisen should be empty");
232 ············}
233 ········}
234
235 ········[Test]
236 ········public void TestUnloadCache() {
237 ············CreateLänder();
238 ············r.LandHinzufügen(de);
239 ············//pm.UnloadCache();
240 ············Assert.That(Object.ReferenceEquals(de, pm.FindObject(((Land)r.Länder[0]).NDOObjectId)), "Getting same object twice should return same object");
241 ············pm.Save();
242 ············pm.UnloadCache();
243 ············pm.MakeHollow(r);
244 ············Assert.That(1 ==··r.Länder.Count, "Number of Länder");
245 ············Land l = (Land)r.Länder[0];
246 ············Assert.That(l != de, "Getting same object twice should return different objects");
247 ············Assert.That(de.Name ==··l.Name, "Name should be same");
248 ············ObjectId id = l.NDOObjectId;
249 ············l = null;
250 ············pm.UnloadCache();
251 ············Assert.That(pm.FindObject(id) != null, "Should find object");
252 ············pm.UnloadCache();
253 ············Assert.That(1 ==··r.Länder.Count, "Number of Länder");
254 ········}
255
256 ········[Test]
257 ········public void TestMakeTransient() {
258 ············CreateLänder();
259 ············r.LandHinzufügen(de);
260 ············pm.Save();
261 ············ObjectId id = r.NDOObjectId;
262 ············pm.MakeTransient(r);
263 ············Assert.That(((IPersistenceCapable)r).NDOStateManager == null, "Transient object shouldn't have state manager");
264 ············Assert.That(NDOObjectState.Transient ==··r.NDOObjectState, "Wrong state #1");
265 ············Assert.That(id.IsValid(), "Id should still be valid #1");
266 ············pm.Save();
267 ············Land l = (Land)r.Länder[0];
268 ············Assert.That(de.Name ==··l.Name, "Name is wrong");
269 ············Assert.That(Object.ReferenceEquals(de, l), "Land is wrong");
270 ············pm.MakeHollow(m);··// make sure, Reise is loaded fresh during TearDown
271 ········}
272
273 ········[Test]
274 ········public void TestMakeTransientMitarbeiterDeleteFails() {
275 ············CreateLänder();
276 ············r.LandHinzufügen(de);
277 ············pm.Save();
278 ············pm.MakeTransient(r);
279 ············try {
280 ················pm.Delete(m);
281 ················Assert.Fail("Mitarbeiter shouldn't be deletable because Reise is Transient");
282 ············} catch (NDOException) {
283 ············}
284 ············//((Reise)m.Reisen[0]).NDOObjectState = NDOObjectState.Persistent;
285 ········}
286
287
288 ········[Test]
289 ········public void TestDeleteLand() {
290 ············CreateLänder();
291 ············r.LandHinzufügen(de);
292 ············r.LandLöschen(de.Name);
293 ············pm.Save();
294 ············Assert.That(0 ==··r.Länder.Count, "#1 Number of Länder");
295 ············pm.MakeHollow(r);
296 ············Assert.That(0 ==··r.Länder.Count, "#2 Number of Länder");
297 ········}
298
299 ········[Test]
300 ········public void TestDeleteLänder() {
301 ············CreateLänder();
302 ············r.LandHinzufügen(de);
303 ············r.LandHinzufügen(usa);
304 ············r.LandLöschen(de.Name);
305 ············Assert.That(1 ==··r.Länder.Count, "#1 Number of Länder");
306 ············pm.Save();
307 ············Assert.That(Object.ReferenceEquals(usa, r.Länder[0]), "Land is wrong");
308 ············Assert.That(1 ==··r.Länder.Count, "#2 Number of Länder");
309 ············pm.MakeHollow(r);
310 ············Assert.That(1 ==··r.Länder.Count, "#3 Number of Länder");
311 ········}
312
313 ········[Test]
314 ········public void TestDeleteReise() {
315 ············CreateLänder();
316 ············r.LandHinzufügen(de);
317 ············r.LandHinzufügen(usa);
318 ············m.LöscheReisen();
319 ············Assert.That(2 ==··r.Länder.Count, "#1 Number of Länder");
320 ············pm.Save();
321 ············Assert.That(2 ==··r.Länder.Count, "#2 Number of Länder");
322 ········}
323
324 ········[Test]
325 ········public void TestDeleteReiseSave()
326 ········{
327 ············CreateLänder();
328 ············r.LandHinzufügen(de);
329 ············r.LandHinzufügen(usa);
330 ············Assert.That(1 ==··usa.DieReisen.Count, "#1 Number of Reisen");
331 ············Assert.That(1 ==··de.DieReisen.Count, "#2 Number of Reisen");
332 ············pm.Save();
333 ············pm.UnloadCache();
334 ············m.LöscheReisen();
335 ············Assert.That(2 ==··r.Länder.Count, "#1 Number of Länder");
336 ············pm.Save();
337 ············Assert.That(2 ==··r.Länder.Count, "#2 Number of Länder");
338 ············pm.UnloadCache();
339 ············IQuery q = new NDOQuery<Land>(pm, "name LIKE 'D%'");
340 ············IList list = q.Execute();
341 ············Assert.That(1 ==··list.Count, "#3 Number of Länder");
342 ············de = (Land) list[0];
343 ············Assert.That(0 ==··de.DieReisen.Count, "#3 Number of Reisen");
344 ········}
345
346
347 ········[Test]
348 ········public void TestDeleteLänderSave() {
349 ············CreateLänder();
350 ············r.LandHinzufügen(de);
351 ············r.LandHinzufügen(usa);
352 ············pm.Save();
353 ············r.LandLöschen(de.Name);
354 ············pm.Save();
355 ············Assert.That(1 ==··r.Länder.Count, "#1 Number of Länder");
356 ············pm.MakeHollow(r);
357 ············Assert.That(1 ==··r.Länder.Count, "#2 Number of Länder");
358 ········}
359
360 ········[Test]
361 ········public void TestDeleteLänderAbort() {
362 ············CreateLänder();
363 ············r.LandHinzufügen(de);
364 ············r.LandHinzufügen(usa);
365 ············pm.Save();
366 ············r.LandLöschen(de.Name);
367 ············pm.Abort();
368 ············Assert.That(2 ==··r.Länder.Count, "#1 Number of Länder");
369 ············pm.MakeHollow(r);
370 ············Assert.That(2 ==··r.Länder.Count, "#2 Number of Länder");
371 ········}
372
373 ········[Test]
374 ········public void TestMakeHollow() {
375 ············CreateLänder();
376 ············r.LandHinzufügen(de);
377 ············pm.Save();
378 ············pm.MakeHollow(r);
379 ············Assert.That(NDOObjectState.Hollow ==··r.NDOObjectState, "Wrong state #1");
380 ············Land l = (Land)r.Länder[0];
381 ············// Should be in Cache
382 ············Assert.That(NDOObjectState.Persistent ==··l.NDOObjectState, "Wrong state #2");
383 ············Assert.That(de.Name ==··l.Name, "Name is wrong");
384 ············Assert.That(Object.ReferenceEquals(de, l), "Land is wrong");
385 ············Assert.That(1 ==··r.Länder.Count, "#1 Number of Länder");
386 ········}
387
388
389 ········[Test]
390 ········public void TestRefresh() {
391 ············CreateLänder();
392 ············r.LandHinzufügen(de);
393 ············pm.Save();
394 ············pm.MakeHollow(r);
395 ············pm.Refresh(r);
396 ············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "Wrong state #1");
397 ········}
398
399 ········[Test]
400 ········public void TestJoinQuery()
401 ········{
402 ············CreateLänder();
403 ············r.LandHinzufügen(de);
404 ············r.LandHinzufügen(usa);
405
406 ············Reise r2 = CreateReise("ADW");
407 ············r2.LandHinzufügen(de);
408 ············m.Hinzufuegen(r2);
409 ············
410
411 ············pm.Save();
412
413 ············NDOQuery<Reise> q = new NDOQuery<Reise>(pm, "dieLaender.name = {0}");
414 ············q.Parameters.Add( usa.Name );
415 ············IList l = q.Execute();
416 ············Assert.That(1 ==··l.Count, "Wrong number of travels");
417 ········}
418
419 ········[Test]
420 ········public void TestIntermediateTableDelete()
421 ········{
422 ············CreateLänder();
423 ············pm.Save();
424 ············r.LandHinzufügen(de);
425 ············r.LandHinzufügen(usa);
426 ············pm.Save();
427 ············r.LandLöschen(de);
428 ············pm.Delete(de);
429 ············pm.Save();
430 ········}
431
432 ········private Reise CreateReise(string zweck)
433 ········{
434 ············Reise r = new Reise();····
435 ············r.Zweck = zweck;
436 ············return r;
437 ········}
438
439 ········private Mitarbeiter CreateMitarbeiter() {
440 ············Mitarbeiter m = new Mitarbeiter();
441 ············m.Nachname··= "Kocher";
442 ············m.Vorname = "Hartmut";
443 ············return m;
444 ········}
445
446 ········private void CreateLänder() {
447 ············usa = new Land("US");
448 ············pm.MakePersistent(usa);
449 ············de = new Land("DE");
450 ············pm.MakePersistent(de);
451 ········}
452 ····}
453 }
454
455