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