Datei: IntegrationTests/NdoUnitTests/NDOMitarbeiterReiseTests.cs
Last Commit (f90cc9c)
1 | // |
2 | // Copyright (c) 2002-2016 Mirko Matytschak |
3 | // (www.netdataobjects.de) |
4 | // |
5 | // Author: Mirko Matytschak |
6 | // |
7 | // Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated |
8 | // documentation files (the "Software"), to deal in the Software without restriction, including without limitation |
9 | // the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the |
10 | // Software, and to permit persons to whom the Software is furnished to do so, subject to the following |
11 | // conditions: |
12 | |
13 | // The above copyright notice and this permission notice shall be included in all copies or substantial portions |
14 | // of the Software. |
15 | // |
16 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED |
17 | // TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
18 | // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF |
19 | // CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
20 | // DEALINGS IN THE SOFTWARE. |
21 | |
22 | |
23 | using System; |
24 | using System.Linq; |
25 | using System.Reflection; |
26 | using System.Collections; |
27 | using System.Collections.Generic; |
28 | using NUnit.Framework; |
29 | using NDO; |
30 | using NDO.Query; |
31 | using Reisekosten; |
32 | using Reisekosten.Personal; |
33 | using NDO.Linq; |
34 | using NDO.Mapping; |
35 | |
36 | namespace NdoUnitTests |
37 | { |
38 | ····/// <summary> |
39 | ····/// Combined Tests of Mitarbeiter and Reise to test uniqueness of object ids. |
40 | ····/// </summary> |
41 | ····[TestFixture] |
42 | ····public class NDOMitarbeiterReiseTests |
43 | ····{ |
44 | ········public NDOMitarbeiterReiseTests() |
45 | ········{ |
46 | ········} |
47 | |
48 | ········private PersistenceManager pm; |
49 | ········private Mitarbeiter m; |
50 | ········private Reise r; |
51 | |
52 | ········[SetUp] |
53 | ········public void Setup() { |
54 | ············pm = PmFactory.NewPersistenceManager(); |
55 | ············m = CreateMitarbeiter("Hartmut", "Kocher"); |
56 | ············r = CreateReise("ADC"); |
57 | ········} |
58 | |
59 | ········[TearDown] |
60 | ········public void TearDown() { |
61 | ············pm.Abort(); |
62 | ············pm.UnloadCache(); |
63 | ············IList mitarbeiterListe = pm.GetClassExtent(typeof(Mitarbeiter), true); |
64 | ············pm.Delete(mitarbeiterListe); |
65 | ············pm.Save(); |
66 | ············pm.Close(); |
67 | ············pm.GetSqlPassThroughHandler().Execute( "DELETE FROM " + pm.NDOMapping.FindClass( typeof( Reise ) ).TableName ); |
68 | ············pm.Dispose(); |
69 | ········} |
70 | |
71 | ········[Test] |
72 | ········public void TestCreateObjects() { |
73 | ············pm.MakePersistent(m); |
74 | ············pm.MakePersistent(r); |
75 | ············Assert.That(!m.NDOObjectId.Equals(r.NDOObjectId), "Ids should be different"); |
76 | ············m = (Mitarbeiter)pm.FindObject(m.NDOObjectId); |
77 | ············r = (Reise)pm.FindObject(r.NDOObjectId); |
78 | ········} |
79 | |
80 | ········[Test] |
81 | ········public void TestCreateObjectsSave() { |
82 | ············m.Hinzufuegen(r); |
83 | ············pm.MakePersistent(m); |
84 | ············pm.Save(); |
85 | ············Assert.That(!m.NDOObjectId.Equals(r.NDOObjectId), "Ids should be different"); |
86 | ············m = (Mitarbeiter)pm.FindObject(m.NDOObjectId); |
87 | ············r = (Reise)pm.FindObject(r.NDOObjectId); |
88 | ············Assert.NotNull(m, "1. Mitarbeiter not found"); |
89 | ············Assert.NotNull(r, "1. Reise not found"); |
90 | |
91 | ············pm.UnloadCache(); |
92 | ············m = (Mitarbeiter)pm.FindObject(m.NDOObjectId); |
93 | ············r = (Reise)pm.FindObject(r.NDOObjectId); |
94 | ············Assert.NotNull(m, "2. Mitarbeiter not found"); |
95 | ············Assert.NotNull(r, "2. Reise not found"); |
96 | ········} |
97 | |
98 | ········[Test] |
99 | ········public void TestAddObjectSave() { |
100 | ············pm.MakePersistent(m); |
101 | ············pm.Save(); |
102 | ············m.Hinzufuegen(r); |
103 | ············Assert.AreEqual(NDOObjectState.Created, r.NDOObjectState, "1. Wrong state"); |
104 | ············pm.Save(); |
105 | ············m = (Mitarbeiter)pm.FindObject(m.NDOObjectId); |
106 | ············r = (Reise)pm.FindObject(r.NDOObjectId); |
107 | ············Assert.NotNull(m, "1. Mitarbeiter not found"); |
108 | ············Assert.NotNull(r, "1. Reise not found"); |
109 | ············Assert.AreEqual(NDOObjectState.Persistent, r.NDOObjectState, "2. Wrong state"); |
110 | ········} |
111 | |
112 | ········int GetOrdinal(Relation r) |
113 | ········{ |
114 | ············var t = r.Parent.SystemType; |
115 | ············Type mcType = t.GetNestedType( "MetaClass", BindingFlags.NonPublic | BindingFlags.Public ); |
116 | ············if (null == mcType) |
117 | ················throw new NDOException( 13, "Missing nested class 'MetaClass' for type '" + t.Name + "'; the type doesn't seem to be enhanced." ); |
118 | var mc = ( IMetaClass) Activator. CreateInstance( mcType ) ; |
119 | ············return mc.GetRelationOrdinal( r.FieldName ); |
120 | ········} |
121 | |
122 | ········bool IsLoaded(IPersistentObject pc, Relation r) |
123 | ········{ |
124 | ············return ((IPersistenceCapable)pc).NDOLoadState.RelationLoadState[GetOrdinal( r )]; |
125 | ········} |
126 | |
127 | ········[Test] |
128 | ········public void RestorePreservesRelationLists() |
129 | ········{ |
130 | ············pm.MakePersistent( m ); |
131 | ············pm.Save(); |
132 | ············m.Hinzufuegen( r ); |
133 | ············pm.Save(); |
134 | ············Assert.AreEqual( 1, m.Reisen.Count ); |
135 | |
136 | ············pm.UnloadCache(); |
137 | ············var m2 = pm.Objects<Mitarbeiter>().Single(); |
138 | |
139 | ············var relation = pm.NDOMapping.FindClass( typeof( Mitarbeiter ) ).FindRelation( "dieReisen" ); |
140 | |
141 | ············Assert.That( !IsLoaded( m2, relation ) ); |
142 | ············var list = m2.Reisen; |
143 | ············m2.Vorname = "Testxxxx"; |
144 | |
145 | ············Assert.That( IsLoaded( m2, relation ) ); |
146 | |
147 | ············pm.Restore( m2 ); |
148 | ············m2.Nachname = "Testyyyy"; |
149 | ············pm.Save(); |
150 | |
151 | ············Assert.AreEqual( 1, m2.Reisen.Count ); |
152 | ········} |
153 | |
154 | ········[Test] |
155 | ········public void TestAddObjectAbort() { |
156 | ············pm.MakePersistent(m); |
157 | ············pm.Save(); |
158 | ············m.Hinzufuegen(r); |
159 | ············Assert.AreEqual(NDOObjectState.Created, r.NDOObjectState, "1. Wrong state"); |
160 | ············Assert.AreEqual(1, m.Reisen.Count, "1. Wrong number of objects"); |
161 | ············pm.Abort(); |
162 | ············Assert.AreEqual(NDOObjectState.Transient, r.NDOObjectState, "2. Wrong state"); |
163 | ············Assert.AreEqual(0, m.Reisen.Count, "2. Wrong number of objects"); |
164 | ········} |
165 | ········[Test] |
166 | ········public void TestRemoveObjectSave() { |
167 | ············pm.MakePersistent(m); |
168 | ············m.Hinzufuegen(r); |
169 | ············pm.Save(); |
170 | ············Assert.AreEqual(1, m.Reisen.Count, "1. Wrong number of objects"); |
171 | ············m.Löschen(r); |
172 | ············Assert.AreEqual(NDOObjectState.Deleted, r.NDOObjectState, "1. Wrong state"); |
173 | ············Assert.AreEqual(0, m.Reisen.Count, "2. Wrong number of objects"); |
174 | ············pm.Save(); |
175 | ············Assert.AreEqual(0, m.Reisen.Count, "3. Wrong number of objects"); |
176 | ············Assert.AreEqual(NDOObjectState.Transient, r.NDOObjectState, "2. Wrong state"); |
177 | ········} |
178 | ············ |
179 | ········[Test] |
180 | ········public void TestRemoveObjectAbort() { |
181 | ············pm.MakePersistent(m); |
182 | ············m.Hinzufuegen(r); |
183 | ············pm.Save(); |
184 | ············Assert.AreEqual(1, m.Reisen.Count, "1. Wrong number of objects"); |
185 | ············m.Löschen(r); |
186 | ············Assert.AreEqual(NDOObjectState.Deleted, r.NDOObjectState, "1. Wrong state"); |
187 | ············Assert.AreEqual(0, m.Reisen.Count, "2. Wrong number of objects"); |
188 | ············pm.Abort(); |
189 | ············Assert.AreEqual(1, m.Reisen.Count, "3. Wrong number of objects"); |
190 | ············Assert.AreEqual(NDOObjectState.Persistent, r.NDOObjectState, "2. Wrong state"); |
191 | ········} |
192 | |
193 | ········[Test] |
194 | ········public void TestDeleteSave() { |
195 | ············pm.MakePersistent(m); |
196 | ············m.Hinzufuegen(r); |
197 | ············pm.Save(); |
198 | ············pm.Delete(m); |
199 | ············Assert.AreEqual(NDOObjectState.Deleted, m.NDOObjectState, "1. Wrong state"); |
200 | ············Assert.AreEqual(NDOObjectState.Deleted, r.NDOObjectState, "2. Wrong state"); |
201 | ············pm.Save(); |
202 | ············Assert.AreEqual(NDOObjectState.Transient, m.NDOObjectState, "1. Wrong state"); |
203 | ············Assert.AreEqual(NDOObjectState.Transient, r.NDOObjectState, "2. Wrong state"); |
204 | ········} |
205 | |
206 | |
207 | |
208 | ········[Test] |
209 | ········public void TestDeleteAbort() { |
210 | ············pm.MakePersistent(m); |
211 | ············m.Hinzufuegen(r); |
212 | ············pm.Save(); |
213 | ············pm.Delete(m); |
214 | ············Assert.AreEqual(NDOObjectState.Deleted, m.NDOObjectState, "1. Wrong state"); |
215 | ············Assert.AreEqual(NDOObjectState.Deleted, r.NDOObjectState, "2. Wrong state"); |
216 | ············pm.Abort(); |
217 | ············Assert.AreEqual(NDOObjectState.Persistent, m.NDOObjectState, "1. Wrong state"); |
218 | ············Assert.AreEqual(NDOObjectState.Persistent, r.NDOObjectState, "2. Wrong state"); |
219 | ········} |
220 | |
221 | ········[Test] |
222 | ········public void TestAddRemoveSave() { |
223 | ············pm.MakePersistent(m); |
224 | ············pm.Save(); |
225 | ············m.Hinzufuegen(r); |
226 | ············m.Löschen(r); |
227 | ············Assert.AreEqual(NDOObjectState.Transient, r.NDOObjectState, "1. Wrong state"); |
228 | ············pm.Save(); |
229 | ············Assert.AreEqual(NDOObjectState.Transient, r.NDOObjectState, "2. Wrong state"); |
230 | ········} |
231 | |
232 | ········[Test] |
233 | ········public void TestAddRemoveAbort() { |
234 | ············pm.MakePersistent(m); |
235 | ············pm.Save(); |
236 | ············m.Hinzufuegen(r); |
237 | ············m.Löschen(r); |
238 | ············Assert.AreEqual(NDOObjectState.Transient, r.NDOObjectState, "1. Wrong state"); |
239 | ············pm.Abort(); |
240 | ············Assert.AreEqual(NDOObjectState.Transient, r.NDOObjectState, "2. Wrong state"); |
241 | ········} |
242 | |
243 | ········[Test] |
244 | ········public void TestClearRelatedObjectsSave() { |
245 | ············for(int i = 0; i < 10; i++) { |
246 | ················m.Hinzufuegen(CreateReise(i.ToString())); |
247 | ············} |
248 | ············pm.MakePersistent(m); |
249 | ············pm.Save(); |
250 | ············IList rr = new ArrayList(m.Reisen); |
251 | ············m.LöscheReisen(); |
252 | ············Assert.AreEqual(0, m.Reisen.Count, "1. Wrong number of objects"); |
253 | ············for(int i = 0; i < 10; i++) { |
254 | ················Assert.AreEqual(NDOObjectState.Deleted, ((Reise)rr[i]).NDOObjectState, "2. Wrong state"); |
255 | ············} |
256 | ············pm.Save(); |
257 | ············Assert.AreEqual(0, m.Reisen.Count, "3. Wrong number of objects"); |
258 | ············for(int i = 0; i < 10; i++) { |
259 | ················Assert.AreEqual(NDOObjectState.Transient, ((Reise)rr[i]).NDOObjectState, "4. Wrong state"); |
260 | ············} |
261 | ········} |
262 | |
263 | ········[Test] |
264 | ········public void TestClearRelatedObjectsAbort() { |
265 | ············for(int i = 0; i < 10; i++) { |
266 | ················m.Hinzufuegen(CreateReise(i.ToString())); |
267 | ············} |
268 | ············pm.MakePersistent(m); |
269 | ············pm.Save(); |
270 | ············IList rr = new ArrayList(m.Reisen); |
271 | ············m.LöscheReisen(); |
272 | ············Assert.AreEqual(0, m.Reisen.Count, "1. Wrong number of objects"); |
273 | ············for(int i = 0; i < 10; i++) { |
274 | ················Assert.AreEqual(NDOObjectState.Deleted, ((Reise)rr[i]).NDOObjectState, "2. Wrong state"); |
275 | ············} |
276 | ············pm.Abort(); |
277 | ············Assert.AreEqual(10, m.Reisen.Count, "3. Wrong number of objects"); |
278 | ············for(int i = 0; i < 10; i++) { |
279 | ················Assert.AreEqual(NDOObjectState.Persistent, ((Reise)rr[i]).NDOObjectState, "4. Wrong state"); |
280 | ············} |
281 | ········} |
282 | |
283 | ········[Test] |
284 | ········public void TestAssignRelatedObjectsNullSave() { |
285 | ············for(int i = 0; i < 3; i++) { |
286 | ················m.Hinzufuegen(CreateReise(i.ToString())); |
287 | ············} |
288 | ············pm.MakePersistent(m); |
289 | ············pm.Save(); |
290 | ············IList rr = new ArrayList(m.Reisen); |
291 | ············m.ErsetzeReisen(null); |
292 | ············Assert.Null(m.Reisen, "No objects should be there"); |
293 | ············for(int i = 0; i < 3; i++) { |
294 | ················Assert.AreEqual(NDOObjectState.Deleted, ((Reise)rr[i]).NDOObjectState, "2. Wrong state"); |
295 | ············} |
296 | ············pm.Save(); |
297 | ············Assert.Null(m.Reisen, "No objects should be there"); |
298 | ············for(int i = 0; i < 3; i++) { |
299 | ················Assert.AreEqual(NDOObjectState.Transient, ((Reise)rr[i]).NDOObjectState, "4. Wrong state"); |
300 | ············} |
301 | ········} |
302 | |
303 | ········[Test] |
304 | ········public void TestAssignRelatedObjectsNullAbort() { |
305 | ············for(int i = 0; i < 3; i++) { |
306 | ················m.Hinzufuegen(CreateReise(i.ToString())); |
307 | ············} |
308 | ············pm.MakePersistent(m); |
309 | ············pm.Save(); |
310 | ············IList rr = new ArrayList(m.Reisen); |
311 | ············m.ErsetzeReisen(null); |
312 | ············Assert.Null(m.Reisen, "No objects should be there"); |
313 | ············for(int i = 0; i < 3; i++) { |
314 | ················Assert.AreEqual(NDOObjectState.Deleted, ((Reise)rr[i]).NDOObjectState, "2. Wrong state"); |
315 | ············} |
316 | ············pm.Abort(); |
317 | ············Assert.AreEqual(3, m.Reisen.Count, "3. Wrong number of objects"); |
318 | ············for(int i = 0; i < 3; i++) { |
319 | ················Assert.AreEqual(NDOObjectState.Persistent, ((Reise)rr[i]).NDOObjectState, "4. Wrong state"); |
320 | ············} |
321 | ········} |
322 | |
323 | ········[Test] |
324 | ········public void TestAssignRelatedObjectsSave() { |
325 | ············for(int i = 0; i < 3; i++) { |
326 | ················m.Hinzufuegen(CreateReise(i.ToString())); |
327 | ············} |
328 | ············pm.MakePersistent(m); |
329 | ············pm.Save(); |
330 | ············IList neueReisen = new ArrayList(); |
331 | ············Reise nr = CreateReise("Test"); |
332 | ············neueReisen.Add(nr); |
333 | |
334 | ············IList rr = new ArrayList(m.Reisen); |
335 | ············m.ErsetzeReisen(neueReisen); |
336 | ············Assert.AreEqual(1, m.Reisen.Count, "1. Wrong number of objects"); |
337 | ············for(int i = 0; i < 3; i++) { |
338 | ················Assert.AreEqual(NDOObjectState.Deleted, ((Reise)rr[i]).NDOObjectState, "2. Wrong state"); |
339 | ············} |
340 | ············Assert.AreEqual(NDOObjectState.Created, nr.NDOObjectState, "3. Wrong state"); |
341 | |
342 | ············pm.Save(); |
343 | ············Assert.AreEqual(1, m.Reisen.Count, "4. Wrong number of objects"); |
344 | ············for(int i = 0; i < 3; i++) { |
345 | ················Assert.AreEqual(NDOObjectState.Transient, ((Reise)rr[i]).NDOObjectState, "5. Wrong state"); |
346 | ············} |
347 | ············Assert.AreEqual(NDOObjectState.Persistent, nr.NDOObjectState, "6. Wrong state"); |
348 | ········} |
349 | |
350 | ········[Test] |
351 | ········public void TestAssignRelatedObjectsAbort() { |
352 | ············for(int i = 0; i < 3; i++) { |
353 | ················m.Hinzufuegen(CreateReise(i.ToString())); |
354 | ············} |
355 | ············pm.MakePersistent(m); |
356 | ············pm.Save(); |
357 | ············IList neueReisen = new ArrayList(); |
358 | ············Reise nr = CreateReise("Test"); |
359 | ············neueReisen.Add(nr); |
360 | |
361 | ············IList rr = new ArrayList(m.Reisen); |
362 | ············m.ErsetzeReisen(neueReisen); |
363 | ············Assert.AreEqual(1, m.Reisen.Count, "1. Wrong number of objects"); |
364 | ············for(int i = 0; i < 3; i++) { |
365 | ················Assert.AreEqual(NDOObjectState.Deleted, ((Reise)rr[i]).NDOObjectState, "2. Wrong state"); |
366 | ············} |
367 | ············Assert.AreEqual(NDOObjectState.Created, nr.NDOObjectState, "3. Wrong state"); |
368 | |
369 | ············pm.Abort(); |
370 | ············Assert.AreEqual(3, m.Reisen.Count, "4. Wrong number of objects"); |
371 | ············for(int i = 0; i < 3; i++) { |
372 | ················Assert.AreEqual(NDOObjectState.Persistent, ((Reise)rr[i]).NDOObjectState, "5. Wrong state"); |
373 | ············} |
374 | ············Assert.AreEqual(NDOObjectState.Transient, nr.NDOObjectState, "6. Wrong state"); |
375 | ········} |
376 | |
377 | ········[Test] |
378 | ········public void TestAddNewReise() |
379 | ········{ |
380 | ············m.Hinzufuegen(r); |
381 | ············pm.MakePersistent(m); |
382 | ············pm.Save(); |
383 | ············pm.UnloadCache(); |
384 | ············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>(pm); |
385 | ············m = q.ExecuteSingle(true); |
386 | ············Reise r2 = CreateReise("Schnulli"); |
387 | ············m.Hinzufuegen(r2); |
388 | ············pm.Save(); |
389 | ············m = q.ExecuteSingle(true); |
390 | ············Assert.AreEqual(2, m.Reisen.Count, "Count wrong"); |
391 | ········} |
392 | |
393 | ········[Test] |
394 | ········public void RefreshReloadsRelation() |
395 | ········{ |
396 | ············m.Hinzufuegen( r ); |
397 | ············pm.MakePersistent( m ); |
398 | ············pm.Save(); |
399 | ············PersistenceManager pm2 = PmFactory.NewPersistenceManager(); |
400 | ············Mitarbeiter m2 = pm2.Objects<Mitarbeiter>().ResultTable.First(); |
401 | ············Assert.AreEqual( m.Reisen.Count, m2.Reisen.Count ); |
402 | ············Assert.AreEqual( 1, m.Reisen.Count ); |
403 | ············Reise r2 = new Reise() { Zweck = "Test" }; |
404 | ············m2.Hinzufuegen( r2 ); |
405 | ············pm2.Save(); |
406 | ············Assert.AreEqual( 1, m.Reisen.Count ); |
407 | ············pm.Refresh( m ); |
408 | ············Assert.AreEqual( 2, m.Reisen.Count ); |
409 | ········} |
410 | |
411 | ········[Test] |
412 | ········public void CanIterateThrougRelatedObjectsWithLinq() |
413 | ········{ |
414 | ············m.Hinzufuegen( r ); |
415 | ············r = new Reise() { Zweck = "Test" }; |
416 | ············m.Hinzufuegen( r ); |
417 | ············pm.MakePersistent( m ); |
418 | ············pm.Save(); |
419 | ············Assert.AreEqual( 2, m.Reisen.Count ); |
420 | ············ObjectId oid = m.NDOObjectId; |
421 | ············pm.UnloadCache(); |
422 | ············pm = PmFactory.NewPersistenceManager(); |
423 | ············m = (Mitarbeiter) pm.FindObject( oid ); |
424 | ············Assert.That( m.NDOObjectState == NDOObjectState.Hollow ); |
425 | ············Reise tr = (from reise in m.Reisen where reise.Zweck == "Test" select reise).SingleOrDefault(); |
426 | ············Assert.NotNull( tr ); |
427 | ············Assert.AreEqual( "Test", tr.Zweck ); |
428 | ········} |
429 | |
430 | ········[Test] |
431 | ········public void TestHollow() { |
432 | ············m.Hinzufuegen(r); |
433 | ············pm.MakePersistent(m); |
434 | ············pm.Save(); |
435 | ············pm.MakeHollow(m); |
436 | ············Assert.AreEqual(NDOObjectState.Hollow, m.NDOObjectState, "1: Mitarbeiter should be hollow"); |
437 | ············Assert.AreEqual(NDOObjectState.Persistent, r.NDOObjectState, "1: Reise should be persistent"); |
438 | ············IList reise = m.Reisen; |
439 | |
440 | ············pm.MakeHollow(m, true); |
441 | ············Assert.AreEqual(NDOObjectState.Hollow, m.NDOObjectState, "2: Mitarbeiter should be hollow"); |
442 | ············Assert.AreEqual(NDOObjectState.Hollow, r.NDOObjectState, "2: Reise should be hollow"); |
443 | |
444 | ············reise = m.Reisen; |
445 | ············Assert.AreEqual(NDOObjectState.Persistent, m.NDOObjectState, "3: Mitarbeiter should be persistent"); |
446 | ············Assert.AreEqual(NDOObjectState.Hollow, r.NDOObjectState, "3: Reise should be hollow"); |
447 | ············Assert.AreEqual("ADC", r.Zweck, "3: Reise should have correct Zweck"); |
448 | ············Assert.AreEqual(NDOObjectState.Persistent, r.NDOObjectState, "4: Reise should be persistent"); |
449 | ········} |
450 | |
451 | ········[Test] |
452 | ········public void··TestMakeAllHollow() { |
453 | ············m.Hinzufuegen(r); |
454 | ············pm.MakePersistent(m); |
455 | ············pm.Save(); |
456 | ············pm.MakeAllHollow(); |
457 | ············Assert.AreEqual(NDOObjectState.Hollow, m.NDOObjectState, "1: Mitarbeiter should be hollow"); |
458 | ············Assert.AreEqual(NDOObjectState.Hollow, r.NDOObjectState, "1: Reise should be hollow"); |
459 | ············pm.UnloadCache(); |
460 | ········} |
461 | |
462 | ········[Test] |
463 | ········public void··TestMakeAllHollowUnsaved() { |
464 | ············m.Hinzufuegen(r); |
465 | ············pm.MakePersistent(m); |
466 | ············pm.MakeAllHollow();··// before save, objects cannot be made hollow. => in locked objects |
467 | ············Assert.AreEqual(NDOObjectState.Created, m.NDOObjectState, "1: Mitarbeiter should be created"); |
468 | ············Assert.AreEqual(NDOObjectState.Created, r.NDOObjectState, "1: Reise should be created"); |
469 | ········} |
470 | |
471 | ········[Test] |
472 | ········public void TestLoadRelatedObjects() { |
473 | ············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>(pm, null); |
474 | ············IList dellist = q.Execute(); |
475 | ············pm.Delete(dellist); |
476 | ············pm.Save(); |
477 | ············pm.UnloadCache(); |
478 | |
479 | ············for(int i = 0; i < 10; i++) { |
480 | ················m.Hinzufuegen(CreateReise(i.ToString())); |
481 | ············} |
482 | ············pm.MakePersistent(m); |
483 | ············pm.Save(); |
484 | ············pm.MakeHollow(m, true); |
485 | |
486 | ············IList reisen = new ArrayList(m.Reisen); |
487 | ············Assert.AreEqual(10, reisen.Count, "Array size should be 10"); |
488 | |
489 | ············for(int i = 0; i < 10; i++) { |
490 | ················Reise rr = (Reise)reisen[i]; |
491 | ················Assert.AreEqual(NDOObjectState.Hollow, rr.NDOObjectState, "1: Reise should be hollow"); |
492 | //················if (i.ToString()!= rr.Zweck) |
493 | //················{ |
494 | //····················for (int j = 0; j < 10; j++) |
495 | //························System.Diagnostics.Debug.WriteLine("Reise: " + ((Reise)reisen[j]).Zweck); |
496 | //················} |
497 | #if !ORACLE && !MYSQL && !FIREBIRD |
498 | ················if (rr.NDOObjectId.Id[0] is Int32) |
499 | ····················Assert.AreEqual(i.ToString(), rr.Zweck, "2: Reise should be in right order"); |
500 | #endif |
501 | ············} |
502 | |
503 | |
504 | ············pm.MakeAllHollow(); |
505 | ············pm.UnloadCache(); |
506 | ············IList reisen2 = m.Reisen; |
507 | ············for(int i = 0; i < 10; i++) { |
508 | ················Reise r1 = (Reise)reisen[i]; |
509 | ················Reise r2 = (Reise)reisen2[i]; |
510 | #if !ORACLE && !MYSQL && !FIREBIRD |
511 | ················if (r1.NDOObjectId.Id[0] is Int32) |
512 | ················Assert.AreEqual(i.ToString(), r1.Zweck, "3: Reise should be in right order"); |
513 | #endif |
514 | ················Assert.That(r1 !=··r2, "Objects should be different"); |
515 | ············} |
516 | ········} |
517 | |
518 | ········[Test] |
519 | ········public void TestLoadRelatedObjectsSave() { |
520 | ············pm.MakePersistent(m); |
521 | ············pm.Save(); |
522 | ············for(int i = 0; i < 10; i++) { |
523 | ················m.Hinzufuegen(CreateReise(i.ToString())); |
524 | ············} |
525 | ············pm.Save(); |
526 | ············pm.MakeHollow(m, true); |
527 | |
528 | ············IList reisen = new ArrayList(m.Reisen); |
529 | |
530 | ············for(int i = 0; i < 10; i++) { |
531 | ················Reise rr = (Reise)reisen[i]; |
532 | ················Assert.AreEqual(NDOObjectState.Hollow, rr.NDOObjectState, "1: Reise should be hollow"); |
533 | #if !ORACLE && !MYSQL && !FIREBIRD |
534 | ················if (rr.NDOObjectId.Id[0] is Int32) |
535 | ····················Assert.AreEqual(i.ToString(), rr.Zweck, "2: Reise should be in right order"); |
536 | #endif |
537 | ············} |
538 | |
539 | |
540 | ············pm.MakeAllHollow(); |
541 | ············pm.UnloadCache(); |
542 | ············IList reisen2 = m.Reisen; |
543 | ············for(int i = 0; i < 10; i++) { |
544 | ················Reise r1 = (Reise)reisen[i]; |
545 | ················Reise r2 = (Reise)reisen2[i]; |
546 | #if !ORACLE && !MYSQL && !FIREBIRD |
547 | ················if (r1.NDOObjectId.Id[0] is Int32) |
548 | ················Assert.AreEqual(i.ToString(), r1.Zweck, "3: Reise should be in right order"); |
549 | #endif |
550 | ················Assert.That(r1 !=··r2, "Objects should be different"); |
551 | ············} |
552 | ········} |
553 | |
554 | ········[Test] |
555 | ········public void TestExtentRelatedObjects() { |
556 | ············m.Hinzufuegen(r); |
557 | ············pm.MakePersistent(m); |
558 | ············pm.Save(); |
559 | ············IList liste = pm.GetClassExtent(typeof(Mitarbeiter)); |
560 | ············m = (Mitarbeiter)liste[0]; |
561 | ············Assert.AreEqual(NDOObjectState.Persistent, m.NDOObjectState, "1: Mitarbeiter should be persistent"); |
562 | ············Assert.NotNull(m.Reisen, "2. Relation is missing"); |
563 | ············Assert.AreEqual(1, m.Reisen.Count, "3. Wrong number of objects"); |
564 | ············Assert.AreEqual(NDOObjectState.Persistent, ((Reise)m.Reisen[0]).NDOObjectState, "4.: Reise should be hollow"); |
565 | |
566 | ············pm.UnloadCache(); |
567 | ············liste = pm.GetClassExtent(typeof(Mitarbeiter)); |
568 | ············m = (Mitarbeiter)liste[0]; |
569 | ············Assert.AreEqual(NDOObjectState.Hollow, m.NDOObjectState, "5: Mitarbeiter should be hollow"); |
570 | ············Assert.NotNull(m.Reisen, "6. Relation is missing"); |
571 | ············Assert.AreEqual(1, m.Reisen.Count, "7. Wrong number of objects"); |
572 | ············Assert.AreEqual(NDOObjectState.Hollow, ((Reise)m.Reisen[0]).NDOObjectState, "8.: Reise should be hollow"); |
573 | |
574 | ············pm.UnloadCache(); |
575 | ············liste = pm.GetClassExtent(typeof(Mitarbeiter), false); |
576 | ············m = (Mitarbeiter)liste[0]; |
577 | ············Assert.AreEqual(NDOObjectState.Persistent, m.NDOObjectState, "9: Mitarbeiter should be persistent"); |
578 | ············Assert.NotNull(m.Reisen, "10. Relation is missing"); |
579 | ············Assert.AreEqual(1, m.Reisen.Count, "11. Wrong number of objects"); |
580 | ············Assert.AreEqual(NDOObjectState.Hollow, ((Reise)m.Reisen[0]).NDOObjectState, "12.: Reise should be hollow"); |
581 | ········} |
582 | |
583 | ········[Test] |
584 | ········public void TestReiseChangeReload() |
585 | ········{ |
586 | ············m.Hinzufuegen(r); |
587 | ············pm.MakePersistent(m); |
588 | ············pm.Save(); |
589 | ············pm.UnloadCache(); |
590 | ············var provider = pm.NDOMapping.FindClass( typeof( Reise ) ).Provider; |
591 | ············NDOQuery<Reise> q = new NDOQuery<Reise>(pm, $"zweck LIKE 'A{provider.Wildcard}'"); |
592 | ············r = (Reise) q.ExecuteSingle(true); |
593 | ············r.Zweck = "NewPurpose"; |
594 | ············pm.VerboseMode = true; |
595 | ············pm.Save(); |
596 | ············pm.VerboseMode= false; |
597 | ············NDOQuery<Mitarbeiter> qm = new NDOQuery<Mitarbeiter>(pm); |
598 | ············m = qm.ExecuteSingle(true); |
599 | ············Assert.AreEqual(1, m.Reisen.Count, "Count wrong"); |
600 | ············Assert.AreEqual("NewPurpose", r.Zweck, "Reise wrong"); |
601 | ········} |
602 | |
603 | ········[Test] |
604 | ········public void RelationEmptyAssignment() |
605 | ········{ |
606 | ············m.Hinzufuegen(r); |
607 | ············pm.MakePersistent(m); |
608 | ············pm.Save(); |
609 | ············pm.UnloadCache(); |
610 | ············m = (Mitarbeiter) pm.FindObject(m.NDOObjectId); |
611 | ············//Assert.That(m.Reisen.Count == 1); |
612 | ············m.ErsetzeReisen(new ArrayList()); |
613 | ············pm.Save(); |
614 | ············pm.UnloadCache(); |
615 | //············// This code gets the same result |
616 | //············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>(pm, "oid = {0}"); |
617 | //············q.Parameters.Add(m.NDOObjectId.Id.Value); |
618 | //············m = (Mitarbeiter) q.ExecuteSingle(true); |
619 | |
620 | ············m = (Mitarbeiter) pm.FindObject(m.NDOObjectId); |
621 | ············Assert.That(m.Reisen.Count == 0, "Reisen should be empty"); |
622 | ········} |
623 | |
624 | ········[Test] |
625 | ········public void RelationNullAssignment() |
626 | ········{ |
627 | ············m.Hinzufuegen(r); |
628 | ············pm.MakePersistent(m); |
629 | ············pm.Save(); |
630 | ············pm.UnloadCache(); |
631 | ············m = (Mitarbeiter) pm.FindObject(m.NDOObjectId); |
632 | ············//Assert.That(m.Reisen.Count == 1); |
633 | ············m.ErsetzeReisen(null); |
634 | ············pm.Save(); |
635 | ············pm.UnloadCache(); |
636 | ············m = (Mitarbeiter) pm.FindObject(m.NDOObjectId); |
637 | ············Assert.That(m.Reisen.Count == 0, "Reisen should be empty"); |
638 | ········} |
639 | |
640 | ········[Test] |
641 | //········[Ignore("Erzeugt Exception in TearDown")] |
642 | ········public void AbortedTransaction() |
643 | ········{ |
644 | ············m.Hinzufuegen( r ); |
645 | ············pm.MakePersistent( m ); |
646 | ············pm.Save(); |
647 | ············pm.UnloadCache(); |
648 | |
649 | ············pm.TransactionMode = TransactionMode.Optimistic; |
650 | |
651 | ············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, null ); |
652 | ············m = (Mitarbeiter)q.ExecuteSingle( true ); |
653 | ············m.Vorname = "Hans"; |
654 | ············((Reise)m.Reisen[0]).Zweck = "Neuer Zweck"; |
655 | |
656 | ············FieldInfo fi = pm.NDOMapping.GetType().GetField( "persistenceHandler", BindingFlags.Instance | BindingFlags.NonPublic ); |
657 | |
658 | ············Dictionary<Type, IPersistenceHandler> ht = (Dictionary<Type, IPersistenceHandler>)fi.GetValue( pm.NDOMapping ); |
659 | ············ht.Clear(); |
660 | ············pm.NDOMapping.FindClass( typeof( Reise ) ).FindField( "zweck" ).Column.Name = "nix"; |
661 | |
662 | ············try |
663 | ············{ |
664 | ················pm.Save(); |
665 | ············} |
666 | ············catch |
667 | ············{ |
668 | ················ht.Clear(); |
669 | ················pm.NDOMapping.FindClass( typeof( Reise ) ).FindField( "zweck" ).Column.Name = "Zweck"; |
670 | ················pm.Abort(); |
671 | ············} |
672 | |
673 | ············pm.UnloadCache(); |
674 | ············m = (Mitarbeiter)q.ExecuteSingle( true ); |
675 | ············Assert.AreEqual( "Hartmut", m.Vorname, "Vorname falsch" ); |
676 | ············Assert.AreEqual( "ADC", ((Reise)m.Reisen[0]).Zweck, "Vorname falsch" ); |
677 | ········} |
678 | |
679 | ········[Test] |
680 | ········public void ResolveTest() |
681 | ········{ |
682 | ············// This makes sure, that each resolve delivers a new PersistenceHandler. |
683 | ············var h1 = pm.ConfigContainer.Resolve<IPersistenceHandler>(); |
684 | ············var h2 = pm.ConfigContainer.Resolve<IPersistenceHandler>(); |
685 | ············Assert.IsTrue( !object.ReferenceEquals( h1, h2 ) ); |
686 | ········} |
687 | |
688 | ········[Test] |
689 | ········public void TestListEnumerator() |
690 | ········{ |
691 | ············m.Hinzufuegen(r); |
692 | ············pm.MakePersistent(m); |
693 | ············pm.Save(); |
694 | ············pm.UnloadCache(); |
695 | ············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>(pm, null); |
696 | ············m = (Mitarbeiter) q.ExecuteSingle(true); |
697 | ············IEnumerator ie = m.Reisen.GetEnumerator(); |
698 | ············bool result = ie.MoveNext(); |
699 | ············Assert.That(result, "Enumerator should give a result"); |
700 | ············Assert.NotNull(ie.Current); |
701 | ········} |
702 | |
703 | ········[Test] |
704 | ········public void TestListCount() |
705 | ········{ |
706 | ············m.Hinzufuegen(r); |
707 | ············pm.MakePersistent(m); |
708 | ············pm.Save(); |
709 | ············pm.UnloadCache(); |
710 | ············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>(pm, null); |
711 | ············m = (Mitarbeiter) q.ExecuteSingle(true); |
712 | ············Assert.AreEqual(1, m.Reisen.Count, "Count should be 1"); |
713 | ········} |
714 | |
715 | ········[Test] |
716 | ········public void TestLinqQuery() |
717 | ········{ |
718 | ············m.Hinzufuegen(r); |
719 | ············pm.MakePersistent(m); |
720 | ············pm.Save(); |
721 | ············pm.UnloadCache(); |
722 | ············m = (from mi in pm.Objects<Mitarbeiter>() where mi.Reisen[Any.Index].Zweck == "ADC" select mi).FirstOrDefault(); |
723 | ············Assert.NotNull(m, "There should be 1 object"); |
724 | ············Assert.AreEqual(1, m.Reisen.Count, "Count should be 1"); |
725 | ········} |
726 | |
727 | |
728 | ········private Mitarbeiter CreateMitarbeiter(string vorname, string nachname) |
729 | ········{ |
730 | ············Mitarbeiter m = new Mitarbeiter(); |
731 | ············m.Vorname = vorname; |
732 | ············m.Nachname = nachname; |
733 | ············return m; |
734 | ········} |
735 | |
736 | ········private Reise CreateReise(string zweck) { |
737 | ············Reise r = new Reise(); |
738 | ············r.Zweck = zweck; |
739 | ············return r; |
740 | ········} |
741 | ····} |
742 | } |
743 |
New Commit (42f9eb7)
1 | // |
2 | // Copyright (c) 2002-2016 Mirko Matytschak |
3 | // (www.netdataobjects.de) |
4 | // |
5 | // Author: Mirko Matytschak |
6 | // |
7 | // Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated |
8 | // documentation files (the "Software"), to deal in the Software without restriction, including without limitation |
9 | // the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the |
10 | // Software, and to permit persons to whom the Software is furnished to do so, subject to the following |
11 | // conditions: |
12 | |
13 | // The above copyright notice and this permission notice shall be included in all copies or substantial portions |
14 | // of the Software. |
15 | // |
16 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED |
17 | // TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
18 | // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF |
19 | // CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
20 | // DEALINGS IN THE SOFTWARE. |
21 | |
22 | |
23 | using System; |
24 | using System.Linq; |
25 | using System.Reflection; |
26 | using System.Collections; |
27 | using System.Collections.Generic; |
28 | using NUnit.Framework; |
29 | using NDO; |
30 | using NDO.Query; |
31 | using Reisekosten; |
32 | using Reisekosten.Personal; |
33 | using NDO.Linq; |
34 | using NDO.Mapping; |
35 | |
36 | namespace NdoUnitTests |
37 | { |
38 | ····/// <summary> |
39 | ····/// Combined Tests of Mitarbeiter and Reise to test uniqueness of object ids. |
40 | ····/// </summary> |
41 | ····[TestFixture] |
42 | ····public class NDOMitarbeiterReiseTests |
43 | ····{ |
44 | ········public NDOMitarbeiterReiseTests() |
45 | ········{ |
46 | ········} |
47 | |
48 | ········private PersistenceManager pm; |
49 | ········private Mitarbeiter m; |
50 | ········private Reise r; |
51 | |
52 | ········[SetUp] |
53 | ········public void Setup() { |
54 | ············pm = PmFactory.NewPersistenceManager(); |
55 | ············m = CreateMitarbeiter("Hartmut", "Kocher"); |
56 | ············r = CreateReise("ADC"); |
57 | ········} |
58 | |
59 | ········[TearDown] |
60 | ········public void TearDown() { |
61 | ············pm.Abort(); |
62 | ············pm.UnloadCache(); |
63 | ············IList mitarbeiterListe = pm.GetClassExtent(typeof(Mitarbeiter), true); |
64 | ············pm.Delete(mitarbeiterListe); |
65 | ············pm.Save(); |
66 | ············pm.Close(); |
67 | ············pm.GetSqlPassThroughHandler().Execute( "DELETE FROM " + pm.NDOMapping.FindClass( typeof( Reise ) ).TableName ); |
68 | ············pm.Dispose(); |
69 | ········} |
70 | |
71 | ········[Test] |
72 | ········public void TestCreateObjects() { |
73 | ············pm.MakePersistent(m); |
74 | ············pm.MakePersistent(r); |
75 | ············Assert.That(!m.NDOObjectId.Equals(r.NDOObjectId), "Ids should be different"); |
76 | ············m = (Mitarbeiter)pm.FindObject(m.NDOObjectId); |
77 | ············r = (Reise)pm.FindObject(r.NDOObjectId); |
78 | ········} |
79 | |
80 | ········[Test] |
81 | ········public void TestCreateObjectsSave() { |
82 | ············m.Hinzufuegen(r); |
83 | ············pm.MakePersistent(m); |
84 | ············pm.Save(); |
85 | ············Assert.That(!m.NDOObjectId.Equals(r.NDOObjectId), "Ids should be different"); |
86 | ············m = (Mitarbeiter)pm.FindObject(m.NDOObjectId); |
87 | ············r = (Reise)pm.FindObject(r.NDOObjectId); |
88 | ············Assert.NotNull(m, "1. Mitarbeiter not found"); |
89 | ············Assert.NotNull(r, "1. Reise not found"); |
90 | |
91 | ············pm.UnloadCache(); |
92 | ············m = (Mitarbeiter)pm.FindObject(m.NDOObjectId); |
93 | ············r = (Reise)pm.FindObject(r.NDOObjectId); |
94 | ············Assert.NotNull(m, "2. Mitarbeiter not found"); |
95 | ············Assert.NotNull(r, "2. Reise not found"); |
96 | ········} |
97 | |
98 | ········[Test] |
99 | ········public void TestAddObjectSave() { |
100 | ············pm.MakePersistent(m); |
101 | ············pm.Save(); |
102 | ············m.Hinzufuegen(r); |
103 | ············Assert.AreEqual(NDOObjectState.Created, r.NDOObjectState, "1. Wrong state"); |
104 | ············pm.Save(); |
105 | ············m = (Mitarbeiter)pm.FindObject(m.NDOObjectId); |
106 | ············r = (Reise)pm.FindObject(r.NDOObjectId); |
107 | ············Assert.NotNull(m, "1. Mitarbeiter not found"); |
108 | ············Assert.NotNull(r, "1. Reise not found"); |
109 | ············Assert.AreEqual(NDOObjectState.Persistent, r.NDOObjectState, "2. Wrong state"); |
110 | ········} |
111 | |
112 | ········int GetOrdinal(Relation r) |
113 | ········{ |
114 | ············var t = r.Parent.SystemType; |
115 | ············Type mcType = t.GetNestedType( "MetaClass", BindingFlags.NonPublic | BindingFlags.Public ); |
116 | ············if (null == mcType) |
117 | ················throw new NDOException( 13, "Missing nested class 'MetaClass' for type '" + t.Name + "'; the type doesn't seem to be enhanced." ); |
118 | var mc = ( IMetaClass) Activator. CreateInstance( mcType, t ) ; |
119 | ············return mc.GetRelationOrdinal( r.FieldName ); |
120 | ········} |
121 | |
122 | ········bool IsLoaded(IPersistentObject pc, Relation r) |
123 | ········{ |
124 | ············return ((IPersistenceCapable)pc).NDOLoadState.RelationLoadState[GetOrdinal( r )]; |
125 | ········} |
126 | |
127 | ········[Test] |
128 | ········public void RestorePreservesRelationLists() |
129 | ········{ |
130 | ············pm.MakePersistent( m ); |
131 | ············pm.Save(); |
132 | ············m.Hinzufuegen( r ); |
133 | ············pm.Save(); |
134 | ············Assert.AreEqual( 1, m.Reisen.Count ); |
135 | |
136 | ············pm.UnloadCache(); |
137 | ············var m2 = pm.Objects<Mitarbeiter>().Single(); |
138 | |
139 | ············var relation = pm.NDOMapping.FindClass( typeof( Mitarbeiter ) ).FindRelation( "dieReisen" ); |
140 | |
141 | ············Assert.That( !IsLoaded( m2, relation ) ); |
142 | ············var list = m2.Reisen; |
143 | ············m2.Vorname = "Testxxxx"; |
144 | |
145 | ············Assert.That( IsLoaded( m2, relation ) ); |
146 | |
147 | ············pm.Restore( m2 ); |
148 | ············m2.Nachname = "Testyyyy"; |
149 | ············pm.Save(); |
150 | |
151 | ············Assert.AreEqual( 1, m2.Reisen.Count ); |
152 | ········} |
153 | |
154 | ········[Test] |
155 | ········public void TestAddObjectAbort() { |
156 | ············pm.MakePersistent(m); |
157 | ············pm.Save(); |
158 | ············m.Hinzufuegen(r); |
159 | ············Assert.AreEqual(NDOObjectState.Created, r.NDOObjectState, "1. Wrong state"); |
160 | ············Assert.AreEqual(1, m.Reisen.Count, "1. Wrong number of objects"); |
161 | ············pm.Abort(); |
162 | ············Assert.AreEqual(NDOObjectState.Transient, r.NDOObjectState, "2. Wrong state"); |
163 | ············Assert.AreEqual(0, m.Reisen.Count, "2. Wrong number of objects"); |
164 | ········} |
165 | ········[Test] |
166 | ········public void TestRemoveObjectSave() { |
167 | ············pm.MakePersistent(m); |
168 | ············m.Hinzufuegen(r); |
169 | ············pm.Save(); |
170 | ············Assert.AreEqual(1, m.Reisen.Count, "1. Wrong number of objects"); |
171 | ············m.Löschen(r); |
172 | ············Assert.AreEqual(NDOObjectState.Deleted, r.NDOObjectState, "1. Wrong state"); |
173 | ············Assert.AreEqual(0, m.Reisen.Count, "2. Wrong number of objects"); |
174 | ············pm.Save(); |
175 | ············Assert.AreEqual(0, m.Reisen.Count, "3. Wrong number of objects"); |
176 | ············Assert.AreEqual(NDOObjectState.Transient, r.NDOObjectState, "2. Wrong state"); |
177 | ········} |
178 | ············ |
179 | ········[Test] |
180 | ········public void TestRemoveObjectAbort() { |
181 | ············pm.MakePersistent(m); |
182 | ············m.Hinzufuegen(r); |
183 | ············pm.Save(); |
184 | ············Assert.AreEqual(1, m.Reisen.Count, "1. Wrong number of objects"); |
185 | ············m.Löschen(r); |
186 | ············Assert.AreEqual(NDOObjectState.Deleted, r.NDOObjectState, "1. Wrong state"); |
187 | ············Assert.AreEqual(0, m.Reisen.Count, "2. Wrong number of objects"); |
188 | ············pm.Abort(); |
189 | ············Assert.AreEqual(1, m.Reisen.Count, "3. Wrong number of objects"); |
190 | ············Assert.AreEqual(NDOObjectState.Persistent, r.NDOObjectState, "2. Wrong state"); |
191 | ········} |
192 | |
193 | ········[Test] |
194 | ········public void TestDeleteSave() { |
195 | ············pm.MakePersistent(m); |
196 | ············m.Hinzufuegen(r); |
197 | ············pm.Save(); |
198 | ············pm.Delete(m); |
199 | ············Assert.AreEqual(NDOObjectState.Deleted, m.NDOObjectState, "1. Wrong state"); |
200 | ············Assert.AreEqual(NDOObjectState.Deleted, r.NDOObjectState, "2. Wrong state"); |
201 | ············pm.Save(); |
202 | ············Assert.AreEqual(NDOObjectState.Transient, m.NDOObjectState, "1. Wrong state"); |
203 | ············Assert.AreEqual(NDOObjectState.Transient, r.NDOObjectState, "2. Wrong state"); |
204 | ········} |
205 | |
206 | |
207 | |
208 | ········[Test] |
209 | ········public void TestDeleteAbort() { |
210 | ············pm.MakePersistent(m); |
211 | ············m.Hinzufuegen(r); |
212 | ············pm.Save(); |
213 | ············pm.Delete(m); |
214 | ············Assert.AreEqual(NDOObjectState.Deleted, m.NDOObjectState, "1. Wrong state"); |
215 | ············Assert.AreEqual(NDOObjectState.Deleted, r.NDOObjectState, "2. Wrong state"); |
216 | ············pm.Abort(); |
217 | ············Assert.AreEqual(NDOObjectState.Persistent, m.NDOObjectState, "1. Wrong state"); |
218 | ············Assert.AreEqual(NDOObjectState.Persistent, r.NDOObjectState, "2. Wrong state"); |
219 | ········} |
220 | |
221 | ········[Test] |
222 | ········public void TestAddRemoveSave() { |
223 | ············pm.MakePersistent(m); |
224 | ············pm.Save(); |
225 | ············m.Hinzufuegen(r); |
226 | ············m.Löschen(r); |
227 | ············Assert.AreEqual(NDOObjectState.Transient, r.NDOObjectState, "1. Wrong state"); |
228 | ············pm.Save(); |
229 | ············Assert.AreEqual(NDOObjectState.Transient, r.NDOObjectState, "2. Wrong state"); |
230 | ········} |
231 | |
232 | ········[Test] |
233 | ········public void TestAddRemoveAbort() { |
234 | ············pm.MakePersistent(m); |
235 | ············pm.Save(); |
236 | ············m.Hinzufuegen(r); |
237 | ············m.Löschen(r); |
238 | ············Assert.AreEqual(NDOObjectState.Transient, r.NDOObjectState, "1. Wrong state"); |
239 | ············pm.Abort(); |
240 | ············Assert.AreEqual(NDOObjectState.Transient, r.NDOObjectState, "2. Wrong state"); |
241 | ········} |
242 | |
243 | ········[Test] |
244 | ········public void TestClearRelatedObjectsSave() { |
245 | ············for(int i = 0; i < 10; i++) { |
246 | ················m.Hinzufuegen(CreateReise(i.ToString())); |
247 | ············} |
248 | ············pm.MakePersistent(m); |
249 | ············pm.Save(); |
250 | ············IList rr = new ArrayList(m.Reisen); |
251 | ············m.LöscheReisen(); |
252 | ············Assert.AreEqual(0, m.Reisen.Count, "1. Wrong number of objects"); |
253 | ············for(int i = 0; i < 10; i++) { |
254 | ················Assert.AreEqual(NDOObjectState.Deleted, ((Reise)rr[i]).NDOObjectState, "2. Wrong state"); |
255 | ············} |
256 | ············pm.Save(); |
257 | ············Assert.AreEqual(0, m.Reisen.Count, "3. Wrong number of objects"); |
258 | ············for(int i = 0; i < 10; i++) { |
259 | ················Assert.AreEqual(NDOObjectState.Transient, ((Reise)rr[i]).NDOObjectState, "4. Wrong state"); |
260 | ············} |
261 | ········} |
262 | |
263 | ········[Test] |
264 | ········public void TestClearRelatedObjectsAbort() { |
265 | ············for(int i = 0; i < 10; i++) { |
266 | ················m.Hinzufuegen(CreateReise(i.ToString())); |
267 | ············} |
268 | ············pm.MakePersistent(m); |
269 | ············pm.Save(); |
270 | ············IList rr = new ArrayList(m.Reisen); |
271 | ············m.LöscheReisen(); |
272 | ············Assert.AreEqual(0, m.Reisen.Count, "1. Wrong number of objects"); |
273 | ············for(int i = 0; i < 10; i++) { |
274 | ················Assert.AreEqual(NDOObjectState.Deleted, ((Reise)rr[i]).NDOObjectState, "2. Wrong state"); |
275 | ············} |
276 | ············pm.Abort(); |
277 | ············Assert.AreEqual(10, m.Reisen.Count, "3. Wrong number of objects"); |
278 | ············for(int i = 0; i < 10; i++) { |
279 | ················Assert.AreEqual(NDOObjectState.Persistent, ((Reise)rr[i]).NDOObjectState, "4. Wrong state"); |
280 | ············} |
281 | ········} |
282 | |
283 | ········[Test] |
284 | ········public void TestAssignRelatedObjectsNullSave() { |
285 | ············for(int i = 0; i < 3; i++) { |
286 | ················m.Hinzufuegen(CreateReise(i.ToString())); |
287 | ············} |
288 | ············pm.MakePersistent(m); |
289 | ············pm.Save(); |
290 | ············IList rr = new ArrayList(m.Reisen); |
291 | ············m.ErsetzeReisen(null); |
292 | ············Assert.Null(m.Reisen, "No objects should be there"); |
293 | ············for(int i = 0; i < 3; i++) { |
294 | ················Assert.AreEqual(NDOObjectState.Deleted, ((Reise)rr[i]).NDOObjectState, "2. Wrong state"); |
295 | ············} |
296 | ············pm.Save(); |
297 | ············Assert.Null(m.Reisen, "No objects should be there"); |
298 | ············for(int i = 0; i < 3; i++) { |
299 | ················Assert.AreEqual(NDOObjectState.Transient, ((Reise)rr[i]).NDOObjectState, "4. Wrong state"); |
300 | ············} |
301 | ········} |
302 | |
303 | ········[Test] |
304 | ········public void TestAssignRelatedObjectsNullAbort() { |
305 | ············for(int i = 0; i < 3; i++) { |
306 | ················m.Hinzufuegen(CreateReise(i.ToString())); |
307 | ············} |
308 | ············pm.MakePersistent(m); |
309 | ············pm.Save(); |
310 | ············IList rr = new ArrayList(m.Reisen); |
311 | ············m.ErsetzeReisen(null); |
312 | ············Assert.Null(m.Reisen, "No objects should be there"); |
313 | ············for(int i = 0; i < 3; i++) { |
314 | ················Assert.AreEqual(NDOObjectState.Deleted, ((Reise)rr[i]).NDOObjectState, "2. Wrong state"); |
315 | ············} |
316 | ············pm.Abort(); |
317 | ············Assert.AreEqual(3, m.Reisen.Count, "3. Wrong number of objects"); |
318 | ············for(int i = 0; i < 3; i++) { |
319 | ················Assert.AreEqual(NDOObjectState.Persistent, ((Reise)rr[i]).NDOObjectState, "4. Wrong state"); |
320 | ············} |
321 | ········} |
322 | |
323 | ········[Test] |
324 | ········public void TestAssignRelatedObjectsSave() { |
325 | ············for(int i = 0; i < 3; i++) { |
326 | ················m.Hinzufuegen(CreateReise(i.ToString())); |
327 | ············} |
328 | ············pm.MakePersistent(m); |
329 | ············pm.Save(); |
330 | ············IList neueReisen = new ArrayList(); |
331 | ············Reise nr = CreateReise("Test"); |
332 | ············neueReisen.Add(nr); |
333 | |
334 | ············IList rr = new ArrayList(m.Reisen); |
335 | ············m.ErsetzeReisen(neueReisen); |
336 | ············Assert.AreEqual(1, m.Reisen.Count, "1. Wrong number of objects"); |
337 | ············for(int i = 0; i < 3; i++) { |
338 | ················Assert.AreEqual(NDOObjectState.Deleted, ((Reise)rr[i]).NDOObjectState, "2. Wrong state"); |
339 | ············} |
340 | ············Assert.AreEqual(NDOObjectState.Created, nr.NDOObjectState, "3. Wrong state"); |
341 | |
342 | ············pm.Save(); |
343 | ············Assert.AreEqual(1, m.Reisen.Count, "4. Wrong number of objects"); |
344 | ············for(int i = 0; i < 3; i++) { |
345 | ················Assert.AreEqual(NDOObjectState.Transient, ((Reise)rr[i]).NDOObjectState, "5. Wrong state"); |
346 | ············} |
347 | ············Assert.AreEqual(NDOObjectState.Persistent, nr.NDOObjectState, "6. Wrong state"); |
348 | ········} |
349 | |
350 | ········[Test] |
351 | ········public void TestAssignRelatedObjectsAbort() { |
352 | ············for(int i = 0; i < 3; i++) { |
353 | ················m.Hinzufuegen(CreateReise(i.ToString())); |
354 | ············} |
355 | ············pm.MakePersistent(m); |
356 | ············pm.Save(); |
357 | ············IList neueReisen = new ArrayList(); |
358 | ············Reise nr = CreateReise("Test"); |
359 | ············neueReisen.Add(nr); |
360 | |
361 | ············IList rr = new ArrayList(m.Reisen); |
362 | ············m.ErsetzeReisen(neueReisen); |
363 | ············Assert.AreEqual(1, m.Reisen.Count, "1. Wrong number of objects"); |
364 | ············for(int i = 0; i < 3; i++) { |
365 | ················Assert.AreEqual(NDOObjectState.Deleted, ((Reise)rr[i]).NDOObjectState, "2. Wrong state"); |
366 | ············} |
367 | ············Assert.AreEqual(NDOObjectState.Created, nr.NDOObjectState, "3. Wrong state"); |
368 | |
369 | ············pm.Abort(); |
370 | ············Assert.AreEqual(3, m.Reisen.Count, "4. Wrong number of objects"); |
371 | ············for(int i = 0; i < 3; i++) { |
372 | ················Assert.AreEqual(NDOObjectState.Persistent, ((Reise)rr[i]).NDOObjectState, "5. Wrong state"); |
373 | ············} |
374 | ············Assert.AreEqual(NDOObjectState.Transient, nr.NDOObjectState, "6. Wrong state"); |
375 | ········} |
376 | |
377 | ········[Test] |
378 | ········public void TestAddNewReise() |
379 | ········{ |
380 | ············m.Hinzufuegen(r); |
381 | ············pm.MakePersistent(m); |
382 | ············pm.Save(); |
383 | ············pm.UnloadCache(); |
384 | ············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>(pm); |
385 | ············m = q.ExecuteSingle(true); |
386 | ············Reise r2 = CreateReise("Schnulli"); |
387 | ············m.Hinzufuegen(r2); |
388 | ············pm.Save(); |
389 | ············m = q.ExecuteSingle(true); |
390 | ············Assert.AreEqual(2, m.Reisen.Count, "Count wrong"); |
391 | ········} |
392 | |
393 | ········[Test] |
394 | ········public void RefreshReloadsRelation() |
395 | ········{ |
396 | ············m.Hinzufuegen( r ); |
397 | ············pm.MakePersistent( m ); |
398 | ············pm.Save(); |
399 | ············PersistenceManager pm2 = PmFactory.NewPersistenceManager(); |
400 | ············Mitarbeiter m2 = pm2.Objects<Mitarbeiter>().ResultTable.First(); |
401 | ············Assert.AreEqual( m.Reisen.Count, m2.Reisen.Count ); |
402 | ············Assert.AreEqual( 1, m.Reisen.Count ); |
403 | ············Reise r2 = new Reise() { Zweck = "Test" }; |
404 | ············m2.Hinzufuegen( r2 ); |
405 | ············pm2.Save(); |
406 | ············Assert.AreEqual( 1, m.Reisen.Count ); |
407 | ············pm.Refresh( m ); |
408 | ············Assert.AreEqual( 2, m.Reisen.Count ); |
409 | ········} |
410 | |
411 | ········[Test] |
412 | ········public void CanIterateThrougRelatedObjectsWithLinq() |
413 | ········{ |
414 | ············m.Hinzufuegen( r ); |
415 | ············r = new Reise() { Zweck = "Test" }; |
416 | ············m.Hinzufuegen( r ); |
417 | ············pm.MakePersistent( m ); |
418 | ············pm.Save(); |
419 | ············Assert.AreEqual( 2, m.Reisen.Count ); |
420 | ············ObjectId oid = m.NDOObjectId; |
421 | ············pm.UnloadCache(); |
422 | ············pm = PmFactory.NewPersistenceManager(); |
423 | ············m = (Mitarbeiter) pm.FindObject( oid ); |
424 | ············Assert.That( m.NDOObjectState == NDOObjectState.Hollow ); |
425 | ············Reise tr = (from reise in m.Reisen where reise.Zweck == "Test" select reise).SingleOrDefault(); |
426 | ············Assert.NotNull( tr ); |
427 | ············Assert.AreEqual( "Test", tr.Zweck ); |
428 | ········} |
429 | |
430 | ········[Test] |
431 | ········public void TestHollow() { |
432 | ············m.Hinzufuegen(r); |
433 | ············pm.MakePersistent(m); |
434 | ············pm.Save(); |
435 | ············pm.MakeHollow(m); |
436 | ············Assert.AreEqual(NDOObjectState.Hollow, m.NDOObjectState, "1: Mitarbeiter should be hollow"); |
437 | ············Assert.AreEqual(NDOObjectState.Persistent, r.NDOObjectState, "1: Reise should be persistent"); |
438 | ············IList reise = m.Reisen; |
439 | |
440 | ············pm.MakeHollow(m, true); |
441 | ············Assert.AreEqual(NDOObjectState.Hollow, m.NDOObjectState, "2: Mitarbeiter should be hollow"); |
442 | ············Assert.AreEqual(NDOObjectState.Hollow, r.NDOObjectState, "2: Reise should be hollow"); |
443 | |
444 | ············reise = m.Reisen; |
445 | ············Assert.AreEqual(NDOObjectState.Persistent, m.NDOObjectState, "3: Mitarbeiter should be persistent"); |
446 | ············Assert.AreEqual(NDOObjectState.Hollow, r.NDOObjectState, "3: Reise should be hollow"); |
447 | ············Assert.AreEqual("ADC", r.Zweck, "3: Reise should have correct Zweck"); |
448 | ············Assert.AreEqual(NDOObjectState.Persistent, r.NDOObjectState, "4: Reise should be persistent"); |
449 | ········} |
450 | |
451 | ········[Test] |
452 | ········public void··TestMakeAllHollow() { |
453 | ············m.Hinzufuegen(r); |
454 | ············pm.MakePersistent(m); |
455 | ············pm.Save(); |
456 | ············pm.MakeAllHollow(); |
457 | ············Assert.AreEqual(NDOObjectState.Hollow, m.NDOObjectState, "1: Mitarbeiter should be hollow"); |
458 | ············Assert.AreEqual(NDOObjectState.Hollow, r.NDOObjectState, "1: Reise should be hollow"); |
459 | ············pm.UnloadCache(); |
460 | ········} |
461 | |
462 | ········[Test] |
463 | ········public void··TestMakeAllHollowUnsaved() { |
464 | ············m.Hinzufuegen(r); |
465 | ············pm.MakePersistent(m); |
466 | ············pm.MakeAllHollow();··// before save, objects cannot be made hollow. => in locked objects |
467 | ············Assert.AreEqual(NDOObjectState.Created, m.NDOObjectState, "1: Mitarbeiter should be created"); |
468 | ············Assert.AreEqual(NDOObjectState.Created, r.NDOObjectState, "1: Reise should be created"); |
469 | ········} |
470 | |
471 | ········[Test] |
472 | ········public void TestLoadRelatedObjects() { |
473 | ············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>(pm, null); |
474 | ············IList dellist = q.Execute(); |
475 | ············pm.Delete(dellist); |
476 | ············pm.Save(); |
477 | ············pm.UnloadCache(); |
478 | |
479 | ············for(int i = 0; i < 10; i++) { |
480 | ················m.Hinzufuegen(CreateReise(i.ToString())); |
481 | ············} |
482 | ············pm.MakePersistent(m); |
483 | ············pm.Save(); |
484 | ············pm.MakeHollow(m, true); |
485 | |
486 | ············IList reisen = new ArrayList(m.Reisen); |
487 | ············Assert.AreEqual(10, reisen.Count, "Array size should be 10"); |
488 | |
489 | ············for(int i = 0; i < 10; i++) { |
490 | ················Reise rr = (Reise)reisen[i]; |
491 | ················Assert.AreEqual(NDOObjectState.Hollow, rr.NDOObjectState, "1: Reise should be hollow"); |
492 | //················if (i.ToString()!= rr.Zweck) |
493 | //················{ |
494 | //····················for (int j = 0; j < 10; j++) |
495 | //························System.Diagnostics.Debug.WriteLine("Reise: " + ((Reise)reisen[j]).Zweck); |
496 | //················} |
497 | #if !ORACLE && !MYSQL && !FIREBIRD |
498 | ················if (rr.NDOObjectId.Id[0] is Int32) |
499 | ····················Assert.AreEqual(i.ToString(), rr.Zweck, "2: Reise should be in right order"); |
500 | #endif |
501 | ············} |
502 | |
503 | |
504 | ············pm.MakeAllHollow(); |
505 | ············pm.UnloadCache(); |
506 | ············IList reisen2 = m.Reisen; |
507 | ············for(int i = 0; i < 10; i++) { |
508 | ················Reise r1 = (Reise)reisen[i]; |
509 | ················Reise r2 = (Reise)reisen2[i]; |
510 | #if !ORACLE && !MYSQL && !FIREBIRD |
511 | ················if (r1.NDOObjectId.Id[0] is Int32) |
512 | ················Assert.AreEqual(i.ToString(), r1.Zweck, "3: Reise should be in right order"); |
513 | #endif |
514 | ················Assert.That(r1 !=··r2, "Objects should be different"); |
515 | ············} |
516 | ········} |
517 | |
518 | ········[Test] |
519 | ········public void TestLoadRelatedObjectsSave() { |
520 | ············pm.MakePersistent(m); |
521 | ············pm.Save(); |
522 | ············for(int i = 0; i < 10; i++) { |
523 | ················m.Hinzufuegen(CreateReise(i.ToString())); |
524 | ············} |
525 | ············pm.Save(); |
526 | ············pm.MakeHollow(m, true); |
527 | |
528 | ············IList reisen = new ArrayList(m.Reisen); |
529 | |
530 | ············for(int i = 0; i < 10; i++) { |
531 | ················Reise rr = (Reise)reisen[i]; |
532 | ················Assert.AreEqual(NDOObjectState.Hollow, rr.NDOObjectState, "1: Reise should be hollow"); |
533 | #if !ORACLE && !MYSQL && !FIREBIRD |
534 | ················if (rr.NDOObjectId.Id[0] is Int32) |
535 | ····················Assert.AreEqual(i.ToString(), rr.Zweck, "2: Reise should be in right order"); |
536 | #endif |
537 | ············} |
538 | |
539 | |
540 | ············pm.MakeAllHollow(); |
541 | ············pm.UnloadCache(); |
542 | ············IList reisen2 = m.Reisen; |
543 | ············for(int i = 0; i < 10; i++) { |
544 | ················Reise r1 = (Reise)reisen[i]; |
545 | ················Reise r2 = (Reise)reisen2[i]; |
546 | #if !ORACLE && !MYSQL && !FIREBIRD |
547 | ················if (r1.NDOObjectId.Id[0] is Int32) |
548 | ················Assert.AreEqual(i.ToString(), r1.Zweck, "3: Reise should be in right order"); |
549 | #endif |
550 | ················Assert.That(r1 !=··r2, "Objects should be different"); |
551 | ············} |
552 | ········} |
553 | |
554 | ········[Test] |
555 | ········public void TestExtentRelatedObjects() { |
556 | ············m.Hinzufuegen(r); |
557 | ············pm.MakePersistent(m); |
558 | ············pm.Save(); |
559 | ············IList liste = pm.GetClassExtent(typeof(Mitarbeiter)); |
560 | ············m = (Mitarbeiter)liste[0]; |
561 | ············Assert.AreEqual(NDOObjectState.Persistent, m.NDOObjectState, "1: Mitarbeiter should be persistent"); |
562 | ············Assert.NotNull(m.Reisen, "2. Relation is missing"); |
563 | ············Assert.AreEqual(1, m.Reisen.Count, "3. Wrong number of objects"); |
564 | ············Assert.AreEqual(NDOObjectState.Persistent, ((Reise)m.Reisen[0]).NDOObjectState, "4.: Reise should be hollow"); |
565 | |
566 | ············pm.UnloadCache(); |
567 | ············liste = pm.GetClassExtent(typeof(Mitarbeiter)); |
568 | ············m = (Mitarbeiter)liste[0]; |
569 | ············Assert.AreEqual(NDOObjectState.Hollow, m.NDOObjectState, "5: Mitarbeiter should be hollow"); |
570 | ············Assert.NotNull(m.Reisen, "6. Relation is missing"); |
571 | ············Assert.AreEqual(1, m.Reisen.Count, "7. Wrong number of objects"); |
572 | ············Assert.AreEqual(NDOObjectState.Hollow, ((Reise)m.Reisen[0]).NDOObjectState, "8.: Reise should be hollow"); |
573 | |
574 | ············pm.UnloadCache(); |
575 | ············liste = pm.GetClassExtent(typeof(Mitarbeiter), false); |
576 | ············m = (Mitarbeiter)liste[0]; |
577 | ············Assert.AreEqual(NDOObjectState.Persistent, m.NDOObjectState, "9: Mitarbeiter should be persistent"); |
578 | ············Assert.NotNull(m.Reisen, "10. Relation is missing"); |
579 | ············Assert.AreEqual(1, m.Reisen.Count, "11. Wrong number of objects"); |
580 | ············Assert.AreEqual(NDOObjectState.Hollow, ((Reise)m.Reisen[0]).NDOObjectState, "12.: Reise should be hollow"); |
581 | ········} |
582 | |
583 | ········[Test] |
584 | ········public void TestReiseChangeReload() |
585 | ········{ |
586 | ············m.Hinzufuegen(r); |
587 | ············pm.MakePersistent(m); |
588 | ············pm.Save(); |
589 | ············pm.UnloadCache(); |
590 | ············var provider = pm.NDOMapping.FindClass( typeof( Reise ) ).Provider; |
591 | ············NDOQuery<Reise> q = new NDOQuery<Reise>(pm, $"zweck LIKE 'A{provider.Wildcard}'"); |
592 | ············r = (Reise) q.ExecuteSingle(true); |
593 | ············r.Zweck = "NewPurpose"; |
594 | ············pm.VerboseMode = true; |
595 | ············pm.Save(); |
596 | ············pm.VerboseMode= false; |
597 | ············NDOQuery<Mitarbeiter> qm = new NDOQuery<Mitarbeiter>(pm); |
598 | ············m = qm.ExecuteSingle(true); |
599 | ············Assert.AreEqual(1, m.Reisen.Count, "Count wrong"); |
600 | ············Assert.AreEqual("NewPurpose", r.Zweck, "Reise wrong"); |
601 | ········} |
602 | |
603 | ········[Test] |
604 | ········public void RelationEmptyAssignment() |
605 | ········{ |
606 | ············m.Hinzufuegen(r); |
607 | ············pm.MakePersistent(m); |
608 | ············pm.Save(); |
609 | ············pm.UnloadCache(); |
610 | ············m = (Mitarbeiter) pm.FindObject(m.NDOObjectId); |
611 | ············//Assert.That(m.Reisen.Count == 1); |
612 | ············m.ErsetzeReisen(new ArrayList()); |
613 | ············pm.Save(); |
614 | ············pm.UnloadCache(); |
615 | //············// This code gets the same result |
616 | //············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>(pm, "oid = {0}"); |
617 | //············q.Parameters.Add(m.NDOObjectId.Id.Value); |
618 | //············m = (Mitarbeiter) q.ExecuteSingle(true); |
619 | |
620 | ············m = (Mitarbeiter) pm.FindObject(m.NDOObjectId); |
621 | ············Assert.That(m.Reisen.Count == 0, "Reisen should be empty"); |
622 | ········} |
623 | |
624 | ········[Test] |
625 | ········public void RelationNullAssignment() |
626 | ········{ |
627 | ············m.Hinzufuegen(r); |
628 | ············pm.MakePersistent(m); |
629 | ············pm.Save(); |
630 | ············pm.UnloadCache(); |
631 | ············m = (Mitarbeiter) pm.FindObject(m.NDOObjectId); |
632 | ············//Assert.That(m.Reisen.Count == 1); |
633 | ············m.ErsetzeReisen(null); |
634 | ············pm.Save(); |
635 | ············pm.UnloadCache(); |
636 | ············m = (Mitarbeiter) pm.FindObject(m.NDOObjectId); |
637 | ············Assert.That(m.Reisen.Count == 0, "Reisen should be empty"); |
638 | ········} |
639 | |
640 | ········[Test] |
641 | //········[Ignore("Erzeugt Exception in TearDown")] |
642 | ········public void AbortedTransaction() |
643 | ········{ |
644 | ············m.Hinzufuegen( r ); |
645 | ············pm.MakePersistent( m ); |
646 | ············pm.Save(); |
647 | ············pm.UnloadCache(); |
648 | |
649 | ············pm.TransactionMode = TransactionMode.Optimistic; |
650 | |
651 | ············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, null ); |
652 | ············m = (Mitarbeiter)q.ExecuteSingle( true ); |
653 | ············m.Vorname = "Hans"; |
654 | ············((Reise)m.Reisen[0]).Zweck = "Neuer Zweck"; |
655 | |
656 | ············FieldInfo fi = pm.NDOMapping.GetType().GetField( "persistenceHandler", BindingFlags.Instance | BindingFlags.NonPublic ); |
657 | |
658 | ············Dictionary<Type, IPersistenceHandler> ht = (Dictionary<Type, IPersistenceHandler>)fi.GetValue( pm.NDOMapping ); |
659 | ············ht.Clear(); |
660 | ············pm.NDOMapping.FindClass( typeof( Reise ) ).FindField( "zweck" ).Column.Name = "nix"; |
661 | |
662 | ············try |
663 | ············{ |
664 | ················pm.Save(); |
665 | ············} |
666 | ············catch |
667 | ············{ |
668 | ················ht.Clear(); |
669 | ················pm.NDOMapping.FindClass( typeof( Reise ) ).FindField( "zweck" ).Column.Name = "Zweck"; |
670 | ················pm.Abort(); |
671 | ············} |
672 | |
673 | ············pm.UnloadCache(); |
674 | ············m = (Mitarbeiter)q.ExecuteSingle( true ); |
675 | ············Assert.AreEqual( "Hartmut", m.Vorname, "Vorname falsch" ); |
676 | ············Assert.AreEqual( "ADC", ((Reise)m.Reisen[0]).Zweck, "Vorname falsch" ); |
677 | ········} |
678 | |
679 | ········[Test] |
680 | ········public void ResolveTest() |
681 | ········{ |
682 | ············// This makes sure, that each resolve delivers a new PersistenceHandler. |
683 | ············var h1 = pm.ConfigContainer.Resolve<IPersistenceHandler>(); |
684 | ············var h2 = pm.ConfigContainer.Resolve<IPersistenceHandler>(); |
685 | ············Assert.IsTrue( !object.ReferenceEquals( h1, h2 ) ); |
686 | ········} |
687 | |
688 | ········[Test] |
689 | ········public void TestListEnumerator() |
690 | ········{ |
691 | ············m.Hinzufuegen(r); |
692 | ············pm.MakePersistent(m); |
693 | ············pm.Save(); |
694 | ············pm.UnloadCache(); |
695 | ············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>(pm, null); |
696 | ············m = (Mitarbeiter) q.ExecuteSingle(true); |
697 | ············IEnumerator ie = m.Reisen.GetEnumerator(); |
698 | ············bool result = ie.MoveNext(); |
699 | ············Assert.That(result, "Enumerator should give a result"); |
700 | ············Assert.NotNull(ie.Current); |
701 | ········} |
702 | |
703 | ········[Test] |
704 | ········public void TestListCount() |
705 | ········{ |
706 | ············m.Hinzufuegen(r); |
707 | ············pm.MakePersistent(m); |
708 | ············pm.Save(); |
709 | ············pm.UnloadCache(); |
710 | ············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>(pm, null); |
711 | ············m = (Mitarbeiter) q.ExecuteSingle(true); |
712 | ············Assert.AreEqual(1, m.Reisen.Count, "Count should be 1"); |
713 | ········} |
714 | |
715 | ········[Test] |
716 | ········public void TestLinqQuery() |
717 | ········{ |
718 | ············m.Hinzufuegen(r); |
719 | ············pm.MakePersistent(m); |
720 | ············pm.Save(); |
721 | ············pm.UnloadCache(); |
722 | ············m = (from mi in pm.Objects<Mitarbeiter>() where mi.Reisen[Any.Index].Zweck == "ADC" select mi).FirstOrDefault(); |
723 | ············Assert.NotNull(m, "There should be 1 object"); |
724 | ············Assert.AreEqual(1, m.Reisen.Count, "Count should be 1"); |
725 | ········} |
726 | |
727 | |
728 | ········private Mitarbeiter CreateMitarbeiter(string vorname, string nachname) |
729 | ········{ |
730 | ············Mitarbeiter m = new Mitarbeiter(); |
731 | ············m.Vorname = vorname; |
732 | ············m.Nachname = nachname; |
733 | ············return m; |
734 | ········} |
735 | |
736 | ········private Reise CreateReise(string zweck) { |
737 | ············Reise r = new Reise(); |
738 | ············r.Zweck = zweck; |
739 | ············return r; |
740 | ········} |
741 | ····} |
742 | } |
743 |