Datei: IntegrationTests/NdoUnitTests/NDOMitarbeiterTests.cs
Last Commit (16046d5)
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.Diagnostics; |
27 | using System.IO; |
28 | using System.Collections; |
29 | using NUnit.Framework; |
30 | using System.Collections.Generic; |
31 | using NDO; |
32 | using Reisekosten.Personal; |
33 | using NDO.Query; |
34 | using NDO.Linq; |
35 | |
36 | namespace NdoUnitTests |
37 | { |
38 | ····[TestFixture] |
39 | ····public class NDOMitarbeiterTests |
40 | ····{ |
41 | ········public NDOMitarbeiterTests() |
42 | ········{ |
43 | ········} |
44 | |
45 | ········private PersistenceManager pm; |
46 | ········private Mitarbeiter m; |
47 | |
48 | |
49 | ········[SetUp] |
50 | ········public void Setup() |
51 | ········{ |
52 | ············pm = PmFactory.NewPersistenceManager(); |
53 | ············m = CreateMitarbeiter("Hartmut", "Kocher"); |
54 | ········} |
55 | |
56 | ········[TearDown] |
57 | ········public void TearDown() |
58 | ········{ |
59 | ············if ( null != pm ) |
60 | ············{ |
61 | ················IList mitarbeiterListe = pm.GetClassExtent( typeof( Mitarbeiter ), true ); |
62 | ················if ( mitarbeiterListe.Count > 0 ) |
63 | ················{ |
64 | ····················pm.Delete( mitarbeiterListe ); |
65 | ····················pm.Save(); |
66 | ················} |
67 | ················pm.Close(); |
68 | ············} |
69 | ········} |
70 | |
71 | ········[Test] |
72 | ········public void TestMappingFileName() |
73 | ········{ |
74 | ············Debug.WriteLine("Mapping file = " + pm.NDOMapping.FileName); |
75 | ········} |
76 | |
77 | |
78 | ········[Test] |
79 | ········public void TestEmptyTransactionSave() |
80 | ········{ |
81 | ············pm.Save(); |
82 | ········} |
83 | |
84 | ········[Test] |
85 | ········public void TestEmptyTransactionAbort() |
86 | ········{ |
87 | ············pm.Abort(); |
88 | ········} |
89 | |
90 | ········/// <summary> |
91 | ········/// This is not a real test, it just ensures that the DB is empty. |
92 | ········/// </summary> |
93 | ········[Test] |
94 | ········public void EmptyDB() |
95 | ········{ |
96 | ············IList mitarbeiterListe = pm.GetClassExtent(typeof(Mitarbeiter), true); |
97 | ············pm.Delete(mitarbeiterListe); |
98 | ············pm.Save(); |
99 | ········} |
100 | |
101 | |
102 | ········[Test] |
103 | ········public void TestObjectCreation() |
104 | ········{ |
105 | ············pm.MakePersistent(m); |
106 | ············Assert.NotNull(m.NDOObjectId, "ObjectId should be valid"); |
107 | ············Assert.AreEqual(NDOObjectState.Created, m.NDOObjectState, "Status wrong"); |
108 | ········} |
109 | |
110 | ········[Test] |
111 | ········public void CheckBits() |
112 | ········{ |
113 | ············Console.WriteLine( "Running as " + (IntPtr.Size * 8) + " bit app." ); |
114 | ········} |
115 | |
116 | ········[Test] |
117 | ········public void CheckPath() |
118 | ········{ |
119 | ············Console.WriteLine( Environment.GetEnvironmentVariable( "PATH" ) ); |
120 | ········} |
121 | |
122 | ········[Test] |
123 | ········public void TestObjectCreationSave() |
124 | ········{ |
125 | ············pm.MakePersistent(m); |
126 | ············pm.Save(); |
127 | ············Assert.AreEqual(NDOObjectState.Persistent, m.NDOObjectState, "Status wrong"); |
128 | ········} |
129 | |
130 | ········[Test] |
131 | ········public void TestRequery() |
132 | ········{ |
133 | ············pm.MakePersistent(m); |
134 | ············pm.Save(); |
135 | ············Mitarbeiter m1 = new NDOQuery<Mitarbeiter>( pm ).ExecuteSingle(); |
136 | ············m1.Nachname = "Matytschak"; |
137 | ············Mitarbeiter m2 = new NDOQuery<Mitarbeiter>( pm ).ExecuteSingle(); |
138 | ············Assert.AreEqual( "Matytschak", m2.Nachname, "Objekt nicht wiederverwendet" ); |
139 | ············m2.Vorname = "Mirko"; |
140 | ········} |
141 | |
142 | ········[Test] |
143 | ········public void TestObjectCreationSaveChanged() |
144 | ········{ |
145 | ············pm.MakePersistent(m); |
146 | ············m.Nachname = "Müller"; |
147 | ············pm.Save(); |
148 | ············Assert.AreEqual("Müller", m.Nachname, "Nachname wrong"); |
149 | ········} |
150 | |
151 | ········[Test] |
152 | ········public void TestObjectCreationAbort() |
153 | ········{ |
154 | ············pm.MakePersistent(m); |
155 | ············pm.Abort(); |
156 | ············Assert.Null(m.NDOObjectId, "Transient object shouldn't have ID"); |
157 | ············Assert.Null(((IPersistenceCapable)m).NDOStateManager, "Transient object shouldn't have state manager"); |
158 | ············Assert.AreEqual(NDOObjectState.Transient, m.NDOObjectState, "Status wrong"); |
159 | ········} |
160 | |
161 | ········[Test] |
162 | ········public void TestObjectCreationAbortChanged() |
163 | ········{ |
164 | ············pm.MakePersistent(m); |
165 | ············m.Nachname = "Müller"; |
166 | ············pm.Abort(); |
167 | ············Assert.AreEqual("Kocher", m.Nachname, "Nachname wrong"); |
168 | ········} |
169 | |
170 | ········[Test] |
171 | ········public void TestObjectId() |
172 | ········{ |
173 | ············pm.MakePersistent(m); |
174 | ············ObjectId id = m.NDOObjectId; |
175 | ············ObjectId id2 = new ObjectId(id); |
176 | ············Assert.AreEqual(m.NDOObjectId, id, "IDs should be equal"); |
177 | ············Assert.AreEqual(m.NDOObjectId, id2, "IDs should be equal"); |
178 | ············if (!pm.HasOwnerCreatedIds && m.NDOObjectId.Id[0] is int) |
179 | ················Assert.That((int)m.NDOObjectId.Id[0] < 0, "Negative key in DS"); |
180 | ············pm.Save(); |
181 | ············Assert.AreEqual(m.NDOObjectId, id, "IDs should be equal"); |
182 | ············Assert.AreEqual(m.NDOObjectId, id2, "IDs should be equal"); |
183 | ············if (!pm.HasOwnerCreatedIds && m.NDOObjectId.Id[0] is int) |
184 | ················Assert.That((int)m.NDOObjectId.Id[0] > 0, "Positive key in DB"); |
185 | ········} |
186 | |
187 | ········[Test] |
188 | ········public void TestCreateDeleteTransitionSave() |
189 | ········{ |
190 | ············pm.MakePersistent(m); |
191 | ············pm.Delete(m); |
192 | ············Assert.Null(m.NDOObjectId, "Transient object shouldn't have ID"); |
193 | ············Assert.Null( ((IPersistenceCapable)m).NDOStateManager, "Transient object shouldn't have state manager"); |
194 | ············Assert.AreEqual(NDOObjectState.Transient, m.NDOObjectState, "Status wrong"); |
195 | ············pm.Save(); |
196 | ············Assert.Null(m.NDOObjectId, "Transient object shouldn't have ID"); |
197 | ············Assert.Null( ((IPersistenceCapable)m).NDOStateManager, "Transient object shouldn't have state manager"); |
198 | ············Assert.AreEqual(NDOObjectState.Transient, m.NDOObjectState, "Status wrong"); |
199 | ········} |
200 | |
201 | ········[Test] |
202 | ········public void TestCreateDeleteTransitionAbort() |
203 | ········{ |
204 | ············pm.MakePersistent(m); |
205 | ············ObjectId id = m.NDOObjectId; |
206 | ············pm.Delete(m); |
207 | ············pm.Abort(); |
208 | ············Assert.Null(m.NDOObjectId, "Transient object shouldn't have ID"); |
209 | ············Assert.Null( ((IPersistenceCapable)m).NDOStateManager, "Transient object shouldn't have state manager"); |
210 | ············Assert.AreEqual(NDOObjectState.Transient, m.NDOObjectState, "Status wrong"); |
211 | ············IPersistenceCapable pc = pm.FindObject(id); |
212 | ············Assert.NotNull( pc, "There should be a hollow object." ); |
213 | ············Assert.AreEqual(NDOObjectState.Hollow, pc.NDOObjectState, "Status wrong"); |
214 | ········} |
215 | |
216 | ········[Test] |
217 | ········public void TestCleanupCache() |
218 | ········{ |
219 | ············pm.MakePersistent(m); |
220 | ············pm.CleanupCache(); |
221 | ············Assert.AreSame(m, pm.FindObject(m.NDOObjectId), "Getting same object twice should return same object"); |
222 | ············pm.Save(); |
223 | ············pm.CleanupCache(); |
224 | ············Assert.AreSame(m, pm.FindObject(m.NDOObjectId), "Getting same object twice should return same object"); |
225 | ············ObjectId id = m.NDOObjectId; |
226 | ············m = null; |
227 | ············pm.CleanupCache(); |
228 | ············Assert.NotNull(pm.FindObject(id), "Should find object"); |
229 | ········} |
230 | |
231 | ········[Test] |
232 | ········public void TestUnloadCache() |
233 | ········{ |
234 | ············pm.MakePersistent(m); |
235 | ············Assert.AreSame(m, pm.FindObject(m.NDOObjectId), "Getting same object twice should return same object"); |
236 | ············pm.Save(); |
237 | ············pm.UnloadCache(); |
238 | ············Assert.That(m != pm.FindObject(m.NDOObjectId), "Getting same object twice should return different objects"); |
239 | ············ObjectId id = m.NDOObjectId; |
240 | ············m = null; |
241 | ············pm.UnloadCache(); |
242 | ············Assert.NotNull(pm.FindObject(id), "Should find object"); |
243 | ········} |
244 | |
245 | ········[Test] |
246 | ········public void PmWithCachedMappingsWorks() |
247 | ········{ |
248 | ············PersistenceManager pm2 = new PersistenceManager( pm.NDOMapping ); |
249 | |
250 | ············pm2.MakePersistent( m ); |
251 | ············pm2.Save(); |
252 | ············pm2.UnloadCache(); |
253 | ············var m2 = pm2.Objects<Mitarbeiter>().First(); |
254 | |
255 | ············Assert.AreEqual( m.NDOObjectId, m2.NDOObjectId ); |
256 | ········} |
257 | |
258 | ········[Test] |
259 | ········public void TestClassExtent() |
260 | ········{ |
261 | ············ArrayList··mliste = new ArrayList(); |
262 | ············for(int i = 0; i < 100; i++) |
263 | ············{ |
264 | ················Mitarbeiter mm = CreateMitarbeiter("Hartmut", i.ToString()); |
265 | ················pm.MakePersistent(mm); |
266 | ················mliste.Add(mm); |
267 | ············} |
268 | |
269 | ············IList mitarbeiterListe = pm.GetClassExtent(typeof(Mitarbeiter)); |
270 | ············Assert.AreEqual(0, mitarbeiterListe.Count, "Current extent should be empty"); |
271 | ············pm.Save(); |
272 | |
273 | ············mitarbeiterListe = pm.GetClassExtent(typeof(Mitarbeiter)); |
274 | ············Assert.AreEqual(100, mitarbeiterListe.Count, "Number of read objects is wrong"); |
275 | ············// Check that all objects come from cache... |
276 | ············foreach(Mitarbeiter m1 in mitarbeiterListe) |
277 | ············{ |
278 | ················Assert.AreEqual(NDOObjectState.Persistent, m1.NDOObjectState, "Wrong state"); |
279 | ············} |
280 | |
281 | ············mliste.Clear(); |
282 | ············mliste = null; |
283 | ············mitarbeiterListe.Clear(); |
284 | ············mitarbeiterListe = null; |
285 | ············//pm.CleanupCache(); |
286 | ············pm.UnloadCache(); |
287 | ············mitarbeiterListe = pm.GetClassExtent(typeof(Mitarbeiter)); |
288 | ············Assert.AreEqual(100, mitarbeiterListe.Count, "Number of read objects is wrong"); |
289 | ············// Check that all objects are reloaded |
290 | ············foreach(Mitarbeiter m1 in mitarbeiterListe) |
291 | ············{ |
292 | ················Assert.AreEqual(NDOObjectState.Hollow, m1.NDOObjectState, "Wrong state"); |
293 | ············} |
294 | ········} |
295 | |
296 | |
297 | ········[Test] |
298 | ········public void TestMakePersistentHierarchy() |
299 | ········{ |
300 | ············Reisekosten.Email email = new Reisekosten.Email(); |
301 | ············m.Hinzufuegen(email); |
302 | ············email.Subject = new Reisekosten.Subject(); |
303 | ············email.Subject.Text = "Test"; |
304 | ············Assert.AreEqual(NDOObjectState.Transient, m.NDOObjectState, "Mitarbeiter muss transient sein"); |
305 | ············Assert.AreEqual(NDOObjectState.Transient, email.NDOObjectState, "Email muss transient sein"); |
306 | ············Assert.AreEqual(NDOObjectState.Transient, email.Subject.NDOObjectState, "Subject muss transient sein"); |
307 | ············pm.MakePersistent(m); |
308 | ············Assert.AreEqual(NDOObjectState.Created, m.NDOObjectState, "Mitarbeiter muss Created sein"); |
309 | ············Assert.AreEqual(NDOObjectState.Created, email.NDOObjectState, "Email muss Created sein"); |
310 | ············Assert.AreEqual(NDOObjectState.Created, email.Subject.NDOObjectState, "Subject muss Created sein"); |
311 | ············pm.Save(); |
312 | ············Assert.AreEqual(NDOObjectState.Persistent, m.NDOObjectState, "Mitarbeiter muss Persistent sein"); |
313 | ············Assert.AreEqual(NDOObjectState.Persistent, email.NDOObjectState, "Email muss Persistent sein"); |
314 | ············Assert.AreEqual(NDOObjectState.Persistent, email.Subject.NDOObjectState, "Subject muss Persistent sein"); |
315 | ············ |
316 | ········} |
317 | |
318 | ········[Test] |
319 | ········public void TestQuery() |
320 | ········{ |
321 | ············ArrayList··mliste = new ArrayList(); |
322 | ············for(int i = 1; i <= 100; i++) |
323 | ············{ |
324 | ················Mitarbeiter mm = CreateMitarbeiter("Hartmut", (i %··3)··== 0 ? "Test" : "xxx"); |
325 | ················pm.MakePersistent(mm); |
326 | ················mliste.Add(mm); |
327 | ············} |
328 | ············pm.Save();········ |
329 | |
330 | ············// Empty query: just like class extent. |
331 | ············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>(pm, null, true); |
332 | ············IList mitarbeiterListe = q.Execute(); |
333 | ············Assert.AreEqual(100, mitarbeiterListe.Count, "Number of read objects is wrong"); |
334 | |
335 | ············q = new NDOQuery<Mitarbeiter>(pm, "nachname = 'Test'", true); |
336 | ············//System.Diagnostics.Debug.WriteLine(q.GeneratedQuery); |
337 | ············mitarbeiterListe = q.Execute(); |
338 | ············Assert.AreEqual(100/3, mitarbeiterListe.Count, "Number of read objects is wrong"); |
339 | ········} |
340 | |
341 | ········[Test] |
342 | ········public void TestLinqQuery() |
343 | ········{ |
344 | ············ArrayList··mliste = new ArrayList(); |
345 | ············for(int i = 1; i <= 100; i++) |
346 | ············{ |
347 | ················Mitarbeiter mm = CreateMitarbeiter("Hartmut", (i % 3)··== 0 ? "Test" : "xxx"); |
348 | ················pm.MakePersistent(mm); |
349 | ················mliste.Add(mm); |
350 | ············} |
351 | ············pm.Save();········ |
352 | ············ |
353 | ············List<Mitarbeiter> mitarbeiterListe = from m in pm.Objects<Mitarbeiter>() select m; |
354 | |
355 | ············Assert.AreEqual(100, mitarbeiterListe.Count, "Number of read objects is wrong #1"); |
356 | |
357 | ············mitarbeiterListe = from m in pm.Objects<Mitarbeiter>() where m.Nachname == "Test" select m; |
358 | ············Assert.AreEqual(100/3, mitarbeiterListe.Count, "Number of read objects is wrong #2"); |
359 | |
360 | ············// Partial select |
361 | ············List<string> nameList = from m in pm.Objects<Mitarbeiter>() select m.Vorname; |
362 | |
363 | ············Assert.AreEqual(100, nameList.Count, "Number of read objects is wrong #3"); |
364 | |
365 | ············nameList = from m in pm.Objects<Mitarbeiter>() where m.Nachname == "Test" select m.Vorname; |
366 | ············Assert.AreEqual(100/3, mitarbeiterListe.Count, "Number of read objects is wrong #4"); |
367 | ········} |
368 | |
369 | ········[Test] |
370 | ········public void LinqQueryWithParameterWorks() |
371 | ········{ |
372 | ············pm.MakePersistent( m ); |
373 | ············pm.Save(); |
374 | ············Mitarbeiter m2 = Mitarbeiter.QueryByName(pm, "Hartmut"); |
375 | ············Assert.NotNull( m2 ); |
376 | ········} |
377 | |
378 | ········[Test] |
379 | ········public void LinqQueryWithNullParameterWorks() |
380 | ········{ |
381 | ············pm.MakePersistent( m ); |
382 | ············pm.Save(); |
383 | ············Mitarbeiter m2 = Mitarbeiter.QueryByName(pm, null); |
384 | ············Assert.IsNull( m2 ); |
385 | ········} |
386 | |
387 | ········[Test] |
388 | ········public void TestDeleteHollow() |
389 | ········{ |
390 | //············System.Diagnostics.Debug.WriteLine("TestDeleteHollow"); |
391 | ············pm.MakePersistent(m); |
392 | ············pm.Save(); |
393 | ············pm.UnloadCache(); |
394 | ············m = (Mitarbeiter)pm.FindObject(m.NDOObjectId); |
395 | ············Assert.AreEqual(NDOObjectState.Hollow, m.NDOObjectState, "Wrong state #1"); |
396 | ············pm.Delete(m); |
397 | ············Assert.AreEqual(NDOObjectState.Deleted, m.NDOObjectState, "Wrong state #2"); |
398 | ············pm.Abort(); |
399 | ············Assert.AreEqual(NDOObjectState.Persistent, m.NDOObjectState, "Wrong state #3"); |
400 | ············pm.UnloadCache(); |
401 | ············m = (Mitarbeiter)pm.FindObject(m.NDOObjectId); |
402 | ············Assert.AreEqual(NDOObjectState.Hollow, m.NDOObjectState, "Wrong state #4"); |
403 | ············pm.Delete(m); |
404 | ············pm.Save(); |
405 | ············Assert.AreEqual(NDOObjectState.Transient, m.NDOObjectState, "Wrong state #5"); |
406 | |
407 | ············IList l = pm.GetClassExtent(typeof(Mitarbeiter)); |
408 | ············Assert.AreEqual(0, l.Count, "Number of read objects is wrong"); |
409 | ········} |
410 | |
411 | ········[Test] |
412 | ········public void TestDeletePersistent() |
413 | ········{ |
414 | ············pm.MakePersistent(m); |
415 | ············pm.Save(); |
416 | ············pm.Delete(m); |
417 | ············Assert.AreEqual(NDOObjectState.Deleted, m.NDOObjectState, "Wrong state #1"); |
418 | ············IList l = pm.GetClassExtent(typeof(Mitarbeiter)); |
419 | ············Assert.AreEqual(1, l.Count, "Number of read objects is wrong"); |
420 | ············pm.Save(); |
421 | ············l = pm.GetClassExtent(typeof(Mitarbeiter)); |
422 | ············Assert.AreEqual(0, l.Count, "Number of read objects is wrong"); |
423 | ········} |
424 | |
425 | ········[Test] |
426 | ········public void TestDeletePersistentDirty() |
427 | ········{ |
428 | ············pm.MakePersistent(m); |
429 | ············pm.Save(); |
430 | ············m.Nachname = "Test"; |
431 | ············Assert.AreEqual(NDOObjectState.PersistentDirty, m.NDOObjectState, "Wrong state #1"); |
432 | ············pm.Delete(m); |
433 | ············Assert.AreEqual(NDOObjectState.Deleted, m.NDOObjectState, "Wrong state #1"); |
434 | ············pm.Abort(); |
435 | ············Assert.AreEqual("Kocher", m.Nachname, "Name shouldn't be changed"); |
436 | ············pm.Delete(m); |
437 | ············pm.Save(); |
438 | ············IList l = pm.GetClassExtent(typeof(Mitarbeiter)); |
439 | ············Assert.AreEqual(0, l.Count, "Number of read objects is wrong"); |
440 | ········} |
441 | |
442 | ········[Test] |
443 | ········public void TestPersistentDirty() |
444 | ········{ |
445 | ············pm.MakePersistent(m); |
446 | ············pm.Save(); |
447 | ············m.Nachname = "Test"; |
448 | ············Assert.AreEqual(NDOObjectState.PersistentDirty, m.NDOObjectState, "Wrong state #1"); |
449 | ············pm.Abort(); |
450 | ············Assert.AreEqual(NDOObjectState.Persistent, m.NDOObjectState, "Wrong state #2"); |
451 | ············Assert.AreEqual("Kocher", m.Nachname, "Name shouldn't be changed"); |
452 | ········} |
453 | |
454 | ········[Test] |
455 | ········public void TestMakeTransient() |
456 | ········{ |
457 | ············pm.MakePersistent(m); |
458 | ············pm.Save(); |
459 | ············ObjectId id = m.NDOObjectId; |
460 | ············pm.MakeTransient(m); |
461 | ············Assert.NotNull(id.Id, "MakeTransient shouldn't remove the ID");············ |
462 | ············Assert.Null( ((IPersistenceCapable)m).NDOStateManager, "Transient object shouldn't have state manager"); |
463 | ············Assert.AreEqual(NDOObjectState.Transient, m.NDOObjectState, "Wrong state #1"); |
464 | ············Assert.That(id.IsValid(), "Id should still be valid #1"); |
465 | ············m = (Mitarbeiter)pm.FindObject(id); |
466 | ············Assert.AreEqual(NDOObjectState.Hollow, m.NDOObjectState, "Wrong state #2"); |
467 | ············pm.MakeTransient(m); |
468 | ············Assert.Null( ((IPersistenceCapable)m).NDOStateManager, "Transient object shouldn't have state manager"); |
469 | ············Assert.AreEqual(NDOObjectState.Transient, m.NDOObjectState, "Wrong state #3"); |
470 | ············Assert.That(id.IsValid(), "Id should still be valid #2"); |
471 | ············m = (Mitarbeiter)pm.FindObject(id); |
472 | ············pm.Delete(m); |
473 | ············pm.Save(); |
474 | ············Assert.That(id.IsValid(), "Id should be valid for the ChangeLog"); |
475 | ········} |
476 | |
477 | ········[Test] |
478 | ········public void TestMakeHollow() |
479 | ········{ |
480 | ············pm.MakePersistent(m); |
481 | ············pm.Save(); |
482 | ············pm.MakeHollow(m); |
483 | ············Assert.AreEqual(NDOObjectState.Hollow, m.NDOObjectState, "Wrong state #1"); |
484 | ············string access = m.Nachname; |
485 | ············Assert.AreEqual(NDOObjectState.Persistent, m.NDOObjectState, "Wrong state #2"); |
486 | ············pm.MakeAllHollow(); |
487 | ············Assert.AreEqual(NDOObjectState.Hollow, m.NDOObjectState, "Wrong state #3"); |
488 | ········} |
489 | |
490 | ········[Test] |
491 | ········public void TestChangeHollow() |
492 | ········{ |
493 | ············pm.MakePersistent(m); |
494 | ············pm.Save(); |
495 | ············pm.MakeHollow(m); |
496 | ············m.Nachname = "Test"; |
497 | ············pm.Abort(); |
498 | ············Assert.AreEqual("Kocher", m.Nachname, "Name shouldn't be changed"); |
499 | ············pm.MakeHollow(m); |
500 | ············m.Nachname = "Test"; |
501 | ············pm.Save(); |
502 | ············Assert.AreEqual("Test", m.Nachname, "Name should be changed"); |
503 | ········} |
504 | |
505 | ········[Test] |
506 | ········public void TestRefreshFailed() |
507 | ········{ |
508 | ············bool thrown = false; |
509 | ············try |
510 | ············{ |
511 | ················pm.Refresh( m ); |
512 | ············} |
513 | ············catch (NDOException) |
514 | ············{ |
515 | ················thrown = true; |
516 | ············} |
517 | ············Assert.AreEqual( true, thrown ); |
518 | ········} |
519 | |
520 | ········[Test] |
521 | ········public void TestRefresh() |
522 | ········{ |
523 | ············pm.MakePersistent(m); |
524 | ············pm.Save(); |
525 | ············pm.MakeHollow(m); |
526 | ············pm.Refresh(m); |
527 | ············Assert.AreEqual(NDOObjectState.Persistent, m.NDOObjectState, "Wrong state #1"); |
528 | ············pm.Refresh(m); |
529 | ············Assert.AreEqual(NDOObjectState.Persistent, m.NDOObjectState, "Wrong state #2"); |
530 | ············ObjectId id = m.NDOObjectId; |
531 | |
532 | ············PersistenceManager pm2 = PmFactory.NewPersistenceManager(); |
533 | ············Mitarbeiter m2 = (Mitarbeiter)pm2.FindObject(id); |
534 | ············Assert.NotNull(m2, "Cannot load object"); |
535 | ············m2.Nachname = "Test"; |
536 | ············pm2.Save(); |
537 | ············pm2.Close(); |
538 | |
539 | ············Assert.AreEqual("Kocher", m.Nachname, "Wrong name #1"); |
540 | ············Assert.AreEqual("Test", m2.Nachname, "Wrong name #2"); |
541 | ············pm.Refresh(m); |
542 | ············Assert.AreEqual("Test", m.Nachname, "Wrong name #3"); |
543 | ········} |
544 | |
545 | ········[Test] |
546 | ········public void TestHollowMode() |
547 | ········{ |
548 | ············pm.MakePersistent(m); |
549 | ············pm.HollowMode = true; |
550 | ············pm.Save();············ |
551 | ············Assert.AreEqual(NDOObjectState.Hollow, m.NDOObjectState, "Wrong state #1"); |
552 | ············m.Nachname = "Test"; |
553 | ············pm.Abort(); |
554 | ············Assert.AreEqual(NDOObjectState.Hollow, m.NDOObjectState, "Wrong state #2"); |
555 | ············m.Nachname = "Test"; |
556 | ············pm.Save(); |
557 | ············Assert.AreEqual(NDOObjectState.Hollow, m.NDOObjectState, "Wrong state #3"); |
558 | ········} |
559 | |
560 | ········[Test] |
561 | ········public void TestAggregateQuery() |
562 | ········{ |
563 | ············Mitarbeiter mm; |
564 | ············IList l = new ArrayList(); |
565 | |
566 | ············for (int i = 0; i < 20; i++) |
567 | ············{ |
568 | ················mm = new Mitarbeiter(); |
569 | ················mm.Vorname = "lkj"; |
570 | ················mm.Nachname = i.ToString(); |
571 | ················mm.Position = new System.Drawing.Point(0, i); |
572 | ················pm.MakePersistent(mm); |
573 | ················l.Add(mm); |
574 | ············} |
575 | ············pm.Save(); |
576 | ············decimal sum = 0m;············ |
577 | ············foreach(Mitarbeiter m2 in l) |
578 | ············{ |
579 | ················sum += m2.Position.Y; |
580 | ············} |
581 | ············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>(pm, null); |
582 | ············decimal newsum = (decimal)q.ExecuteAggregate("position.Y", AggregateType.Sum); |
583 | ············Assert.AreEqual(sum, newsum, "Summe stimmt nicht"); |
584 | ············decimal count = (decimal)q.ExecuteAggregate("position.X", AggregateType.Count); |
585 | ············Assert.AreEqual(20, count, "Count stimmt nicht"); |
586 | ········} |
587 | |
588 | |
589 | ········[Test] |
590 | ········public void LinqTestAggregateQuery() |
591 | ········{ |
592 | ············Mitarbeiter mm; |
593 | ············var l = new List<Mitarbeiter>(); |
594 | |
595 | ············for (int i = 0; i < 20; i++) |
596 | ············{ |
597 | ················mm = new Mitarbeiter(); |
598 | ················mm.Vorname = "lkj"; |
599 | ················mm.Nachname = i.ToString(); |
600 | ················mm.Gehalt = 5000m + i * 100m; |
601 | ················pm.MakePersistent( mm ); |
602 | ················l.Add( mm ); |
603 | ············} |
604 | ············pm.Save(); |
605 | ············decimal sum = 0m; |
606 | ············foreach (Mitarbeiter m2 in l) |
607 | ············{ |
608 | ················sum += m2.Gehalt; |
609 | ············} |
610 | |
611 | ············decimal avg = sum / 20m; |
612 | |
613 | ············var virtualTable = pm.Objects<Mitarbeiter>(); |
614 | |
615 | ············decimal count = virtualTable.Count; |
616 | ············Assert.AreEqual( 20, count, "Count stimmt nicht" ); |
617 | |
618 | ············decimal newsum = virtualTable.Sum( m => m.Gehalt ); |
619 | ············Assert.AreEqual( sum, newsum, "Summe stimmt nicht" ); |
620 | |
621 | ············decimal newavg = virtualTable.Average( m => m.Gehalt ); |
622 | ············Assert.AreEqual( avg, newavg, "Durchschnitt stimmt nicht" ); |
623 | ········} |
624 | |
625 | |
626 | ········[Test] |
627 | ········public void TestPolymorphicQuery() |
628 | ········{ |
629 | ············// If two classes are mapped to the same table, the query |
630 | ············// should give us the class which is given as parameter |
631 | |
632 | ············pm.MakePersistent(m); // Manager with privilegstufe 0 |
633 | ············pm.Save(); |
634 | ············pm.UnloadCache(); |
635 | ············IQuery q = new NDOQuery<Mitarbeiter>(pm, null); |
636 | ············IList l = q.Execute(); |
637 | ············Assert.AreEqual(1, l.Count, "Only one object should be returned"); |
638 | ············Assert.AreEqual(typeof(Mitarbeiter), l[0].GetType(), "Object should be a Mitarbeiter"); |
639 | |
640 | ············// Fetch the same object as manager |
641 | ············q = new NDOQuery<Manager>(pm, null); |
642 | ············l = q.Execute(); |
643 | ············Assert.AreEqual(1, l.Count, "Only one object should be returned"); |
644 | ············Assert.AreEqual(typeof(Manager), l[0].GetType(), "Object should be a Manager"); |
645 | ········} |
646 | |
647 | ········[Test] |
648 | ········public void TestStringLen() |
649 | ········{ |
650 | ············string s = string.Empty; |
651 | ············for (int i = 0; i < 255; i++) |
652 | ············{ |
653 | ················s += "A"; |
654 | ············} |
655 | ············m.Vorname = s; |
656 | ············pm.MakePersistent(m); |
657 | ············pm.Save(); |
658 | ············pm.UnloadCache(); |
659 | ············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>(pm); |
660 | ············Mitarbeiter m2 = (Mitarbeiter) q.ExecuteSingle(true); |
661 | ············Assert.AreEqual(255, m2.Vorname.Length, "Lönge des Vornamens falsch"); |
662 | ········} |
663 | |
664 | |
665 | ········[Test] |
666 | ········public void TestHollowDelete() |
667 | ········{ |
668 | ············pm.MakePersistent(m); |
669 | ············pm.Save(); |
670 | ············pm.UnloadCache(); |
671 | ············// Load hollow |
672 | ············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>(pm, null, true); |
673 | ············IList l = q.Execute(); |
674 | ············Assert.AreEqual(1, l.Count, "Anzahl Mitarbeiter falsch #1"); |
675 | ············pm.Delete(l); |
676 | ············pm.Save(); |
677 | ············pm.UnloadCache(); |
678 | ············q = new NDOQuery<Mitarbeiter>(pm); |
679 | ············l = q.Execute(); |
680 | ············Assert.AreEqual(0, l.Count, "Anzahl Mitarbeiter falsch #2"); |
681 | |
682 | ········} |
683 | |
684 | ········[Test] |
685 | ········public void TestHollowDelete2Pm() |
686 | ········{ |
687 | ············pm.MakePersistent(m); |
688 | ············pm.Save(); |
689 | ············pm.UnloadCache(); |
690 | ············// Load hollow |
691 | ············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>(pm, null, true); |
692 | ············IList l = q.Execute(); |
693 | ············Assert.AreEqual(1, l.Count, "Anzahl Mitarbeiter falsch #1"); |
694 | ············PersistenceManager pm2 = PmFactory.NewPersistenceManager(); |
695 | ············pm2.Delete(l); |
696 | ············pm2.Save(); |
697 | ············q = new NDOQuery<Mitarbeiter>(pm); |
698 | ············l = q.Execute(); |
699 | ············Assert.AreEqual(0, l.Count, "Anzahl Mitarbeiter falsch #2"); |
700 | ········} |
701 | |
702 | |
703 | //········[Test] |
704 | //········void TestVerboseMode() |
705 | //········{ |
706 | //············PersistenceManager pm = new PersistenceManager(); |
707 | // |
708 | //············pm.MakePersistent(m); |
709 | //············pm.Save(); |
710 | // |
711 | //············m.Vorname = "Hallo"; |
712 | // |
713 | //············m.NDOStateManager.PersistenceManager.LogPath = "C:\\Temp"; |
714 | //············Assert.AreEqual(m.NDOStateManager.PersistenceManager.LogPath, pm.LogPath, "LogPath falsch"); |
715 | //············if (File.Exists(pm.LogFile)) |
716 | //················.... |
717 | //············m.NDOStateManager.PersistenceManager.VerboseMode = true; |
718 | //········ |
719 | //············m.NDOStateManager.PersistenceManager.Save();···· |
720 | //········} |
721 | |
722 | |
723 | ········[Test] |
724 | ········public void Angriff() |
725 | ········{ |
726 | //············pm.MakePersistent(m); |
727 | //············pm.Save(); |
728 | ············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>(pm, "nachname LIKE {0}"); |
729 | ············q.Parameters.Add("dummy';SELECT * from Mitarbeiter; --"); |
730 | ············IList l = q.Execute(); |
731 | ········} |
732 | |
733 | ········[Test] |
734 | ········public void LoadDataOnUnknownObjectThrows() |
735 | ········{ |
736 | ············Mitarbeiter m = (Mitarbeiter)pm.FindObject( typeof( Mitarbeiter ), 1000000 ); |
737 | ············bool thrown = false; |
738 | ············try |
739 | ············{ |
740 | ················pm.LoadData( m ); |
741 | ············} |
742 | ············catch (NDOException ex) |
743 | ············{ |
744 | ················Assert.AreEqual( 72, ex.ErrorNumber ); |
745 | ················thrown = true; |
746 | ············} |
747 | |
748 | ············Assert.That( thrown ); |
749 | ········} |
750 | |
751 | ········[Test] |
752 | ········public void LoadDataOnUnknownObjectCallsEventHandler() |
753 | ········{ |
754 | ············pm.ObjectNotPresentEvent += ea => true;··// prevents throwing an exception |
755 | ············Mitarbeiter m = (Mitarbeiter)pm.FindObject( typeof( Mitarbeiter ), 1000000 ); |
756 | ············pm.LoadData( m ); |
757 | ········} |
758 | |
759 | ········[Test] |
760 | ········public void LoadDataReturnsPersistentObject() |
761 | ········{ |
762 | ············pm.MakePersistent( m ); |
763 | ············var oid = m.NDOObjectId; |
764 | ············pm.Save(); |
765 | ············pm.UnloadCache(); |
766 | ············var m2 = pm.FindObject( oid ); |
767 | ············Assert.AreEqual( NDOObjectState.Hollow, m2.NDOObjectState ); |
768 | ············pm.LoadData( m2 ); |
769 | ············Assert.AreEqual( NDOObjectState.Persistent, m2.NDOObjectState ); |
770 | ········} |
771 | |
772 | ········[Test] |
773 | ········public void CanQueryWithInClause() |
774 | ········{ |
775 | ············var pm = PmFactory.NewPersistenceManager(); |
776 | ············var m1 = CreateMitarbeiter("Mirko", "Matytschak"); |
777 | ············var m2 = CreateMitarbeiter("Hans", "Huber"); |
778 | ············pm.MakePersistent( m1 ); |
779 | ············pm.MakePersistent( m2 ); |
780 | ············pm.Save(); |
781 | ············pm.UnloadCache(); |
782 | ············var l = pm.Objects<Mitarbeiter>().Where(m=>m.Vorname.In(new []{ "Mirko" } )).ResultTable; |
783 | ············Assert.AreEqual( 1, l.Count ); |
784 | ············l = pm.Objects<Mitarbeiter>().Where(m=>m.Vorname.In(new []{ "Mirko", "Hans" } )).ResultTable; |
785 | ············Assert.AreEqual( 2, l.Count ); |
786 | ············Assert.AreEqual( 0, QueryByGuid( new[] { Guid.NewGuid() } ).Count ); |
787 | ········} |
788 | |
789 | ········List<Mitarbeiter> QueryByGuid(Guid[] guids) |
790 | ········{ |
791 | ············return pm.Objects<Mitarbeiter>().Where( m => m.Vorname.In( guids ) ); |
792 | ········} |
793 | |
794 | ········[Test] |
795 | ········public void CanInsertObjectsUsingSqlHandler() |
796 | ········{ |
797 | ············var pm = PmFactory.NewPersistenceManager(); |
798 | ············pm.TransactionMode = TransactionMode.None; |
799 | ············using (var handler = pm.GetSqlPassThroughHandler()) |
800 | ············{ |
801 | ················var sql = "INSERT INTO [Mitarbeiter] ([Vorname],[Nachname],[Gehalt]) VALUES (@p0, @p1, @p2)"; |
802 | ················handler.Execute( sql, false, "Fritz", "Müller", 123456.34m ); |
803 | ············} |
804 | ············var m = pm.Objects<Mitarbeiter>().SingleOrDefault(); |
805 | ············Assert.NotNull( m ); |
806 | ············Assert.AreEqual( "Fritz", m.Vorname ); |
807 | ············Assert.AreEqual( "Müller", m.Nachname ); |
808 | ············Assert.AreEqual( 123456.34m, m.Gehalt ); |
809 | ········} |
810 | |
811 | ········[Test] |
812 | ········public void CanInsertObjectsWithNullParameterUsingSqlHandler() |
813 | ········{ |
814 | ············var pm = PmFactory.NewPersistenceManager(); |
815 | ············pm.TransactionMode = TransactionMode.None; |
816 | ············using (var handler = pm.GetSqlPassThroughHandler()) |
817 | ············{ |
818 | ················var sql = "INSERT INTO [Mitarbeiter] ([Vorname],[Nachname],[Gehalt]) VALUES (@p0, @p1, @p2)"; |
819 | ················handler.Execute( sql, false, null, "Müller", 123456.34m ); |
820 | ············} |
821 | ············var m = pm.Objects<Mitarbeiter>().SingleOrDefault(); |
822 | ············Assert.NotNull( m ); |
823 | ············Assert.AreEqual( "Müller", m.Nachname ); |
824 | ············Assert.AreEqual( 123456.34m, m.Gehalt ); |
825 | ········} |
826 | |
827 | ········private Mitarbeiter CreateMitarbeiter(string vorname, string nachname) |
828 | ········{ |
829 | ············Mitarbeiter m = new Mitarbeiter(); |
830 | ············m.Vorname = vorname; |
831 | ············m.Nachname = nachname; |
832 | ············return m; |
833 | ········} |
834 | ····} |
835 | } |
836 |
New Commit (43dcc14)
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.Diagnostics; |
27 | using System.IO; |
28 | using System.Collections; |
29 | using NUnit.Framework; |
30 | using System.Collections.Generic; |
31 | using NDO; |
32 | using Reisekosten.Personal; |
33 | using NDO.Query; |
34 | using NDO.Linq; |
35 | |
36 | namespace NdoUnitTests |
37 | { |
38 | ····[TestFixture] |
39 | ····public class NDOMitarbeiterTests |
40 | ····{ |
41 | ········public NDOMitarbeiterTests() |
42 | ········{ |
43 | ········} |
44 | |
45 | ········private PersistenceManager pm; |
46 | ········private Mitarbeiter m; |
47 | |
48 | |
49 | ········[SetUp] |
50 | ········public void Setup() |
51 | ········{ |
52 | ············pm = PmFactory.NewPersistenceManager(); |
53 | ············m = CreateMitarbeiter("Hartmut", "Kocher"); |
54 | ········} |
55 | |
56 | ········[TearDown] |
57 | ········public void TearDown() |
58 | ········{ |
59 | ············if ( null != pm ) |
60 | ············{ |
61 | ················IList mitarbeiterListe = pm.GetClassExtent( typeof( Mitarbeiter ), true ); |
62 | ················if ( mitarbeiterListe.Count > 0 ) |
63 | ················{ |
64 | ····················pm.Delete( mitarbeiterListe ); |
65 | ····················pm.Save(); |
66 | ················} |
67 | ················pm.Close(); |
68 | ············} |
69 | ········} |
70 | |
71 | ········[Test] |
72 | ········public void TestMappingFileName() |
73 | ········{ |
74 | ············Debug.WriteLine("Mapping file = " + pm.NDOMapping.FileName); |
75 | ········} |
76 | |
77 | |
78 | ········[Test] |
79 | ········public void TestEmptyTransactionSave() |
80 | ········{ |
81 | ············pm.Save(); |
82 | ········} |
83 | |
84 | ········[Test] |
85 | ········public void TestEmptyTransactionAbort() |
86 | ········{ |
87 | ············pm.Abort(); |
88 | ········} |
89 | |
90 | ········/// <summary> |
91 | ········/// This is not a real test, it just ensures that the DB is empty. |
92 | ········/// </summary> |
93 | ········[Test] |
94 | ········public void EmptyDB() |
95 | ········{ |
96 | ············IList mitarbeiterListe = pm.GetClassExtent(typeof(Mitarbeiter), true); |
97 | ············pm.Delete(mitarbeiterListe); |
98 | ············pm.Save(); |
99 | ········} |
100 | |
101 | |
102 | ········[Test] |
103 | ········public void TestObjectCreation() |
104 | ········{ |
105 | ············pm.MakePersistent(m); |
106 | ············Assert.NotNull(m.NDOObjectId, "ObjectId should be valid"); |
107 | ············Assert.AreEqual(NDOObjectState.Created, m.NDOObjectState, "Status wrong"); |
108 | ········} |
109 | |
110 | ········[Test] |
111 | ········public void CheckBits() |
112 | ········{ |
113 | ············Console.WriteLine( "Running as " + (IntPtr.Size * 8) + " bit app." ); |
114 | ········} |
115 | |
116 | ········[Test] |
117 | ········public void CheckPath() |
118 | ········{ |
119 | ············Console.WriteLine( Environment.GetEnvironmentVariable( "PATH" ) ); |
120 | ········} |
121 | |
122 | ········[Test] |
123 | ········public void TestObjectCreationSave() |
124 | ········{ |
125 | ············pm.MakePersistent(m); |
126 | ············pm.Save(); |
127 | ············Assert.AreEqual(NDOObjectState.Persistent, m.NDOObjectState, "Status wrong"); |
128 | ········} |
129 | |
130 | ········[Test] |
131 | ········public void TestRequery() |
132 | ········{ |
133 | ············pm.MakePersistent(m); |
134 | ············pm.Save(); |
135 | ············Mitarbeiter m1 = new NDOQuery<Mitarbeiter>( pm ).ExecuteSingle(); |
136 | ············m1.Nachname = "Matytschak"; |
137 | ············Mitarbeiter m2 = new NDOQuery<Mitarbeiter>( pm ).ExecuteSingle(); |
138 | ············Assert.AreEqual( "Matytschak", m2.Nachname, "Objekt nicht wiederverwendet" ); |
139 | ············m2.Vorname = "Mirko"; |
140 | ········} |
141 | |
142 | ········[Test] |
143 | ········public void TestObjectCreationSaveChanged() |
144 | ········{ |
145 | ············pm.MakePersistent(m); |
146 | ············m.Nachname = "Müller"; |
147 | ············pm.Save(); |
148 | ············Assert.AreEqual("Müller", m.Nachname, "Nachname wrong"); |
149 | ········} |
150 | |
151 | ········[Test] |
152 | ········public void TestObjectCreationAbort() |
153 | ········{ |
154 | ············pm.MakePersistent(m); |
155 | ············pm.Abort(); |
156 | ············Assert.Null(m.NDOObjectId, "Transient object shouldn't have ID"); |
157 | ············Assert.Null(((IPersistenceCapable)m).NDOStateManager, "Transient object shouldn't have state manager"); |
158 | ············Assert.AreEqual(NDOObjectState.Transient, m.NDOObjectState, "Status wrong"); |
159 | ········} |
160 | |
161 | ········[Test] |
162 | ········public void TestObjectCreationAbortChanged() |
163 | ········{ |
164 | ············pm.MakePersistent(m); |
165 | ············m.Nachname = "Müller"; |
166 | ············pm.Abort(); |
167 | ············Assert.AreEqual("Kocher", m.Nachname, "Nachname wrong"); |
168 | ········} |
169 | |
170 | ········[Test] |
171 | ········public void TestObjectId() |
172 | ········{ |
173 | ············pm.MakePersistent(m); |
174 | ············ObjectId id = m.NDOObjectId; |
175 | ············ObjectId id2 = new ObjectId(id); |
176 | ············Assert.AreEqual(m.NDOObjectId, id, "IDs should be equal"); |
177 | ············Assert.AreEqual(m.NDOObjectId, id2, "IDs should be equal"); |
178 | ············if (!pm.HasOwnerCreatedIds && m.NDOObjectId.Id[0] is int) |
179 | ················Assert.That((int)m.NDOObjectId.Id[0] < 0, "Negative key in DS"); |
180 | ············pm.Save(); |
181 | ············Assert.AreEqual(m.NDOObjectId, id, "IDs should be equal"); |
182 | ············Assert.AreEqual(m.NDOObjectId, id2, "IDs should be equal"); |
183 | ············if (!pm.HasOwnerCreatedIds && m.NDOObjectId.Id[0] is int) |
184 | ················Assert.That((int)m.NDOObjectId.Id[0] > 0, "Positive key in DB"); |
185 | ········} |
186 | |
187 | ········[Test] |
188 | ········public void TestCreateDeleteTransitionSave() |
189 | ········{ |
190 | ············pm.MakePersistent(m); |
191 | ············pm.Delete(m); |
192 | ············Assert.Null(m.NDOObjectId, "Transient object shouldn't have ID"); |
193 | ············Assert.Null( ((IPersistenceCapable)m).NDOStateManager, "Transient object shouldn't have state manager"); |
194 | ············Assert.AreEqual(NDOObjectState.Transient, m.NDOObjectState, "Status wrong"); |
195 | ············pm.Save(); |
196 | ············Assert.Null(m.NDOObjectId, "Transient object shouldn't have ID"); |
197 | ············Assert.Null( ((IPersistenceCapable)m).NDOStateManager, "Transient object shouldn't have state manager"); |
198 | ············Assert.AreEqual(NDOObjectState.Transient, m.NDOObjectState, "Status wrong"); |
199 | ········} |
200 | |
201 | ········[Test] |
202 | ········public void TestCreateDeleteTransitionAbort() |
203 | ········{ |
204 | ············pm.MakePersistent(m); |
205 | ············ObjectId id = m.NDOObjectId; |
206 | ············pm.Delete(m); |
207 | ············pm.Abort(); |
208 | ············Assert.Null(m.NDOObjectId, "Transient object shouldn't have ID"); |
209 | ············Assert.Null( ((IPersistenceCapable)m).NDOStateManager, "Transient object shouldn't have state manager"); |
210 | ············Assert.AreEqual(NDOObjectState.Transient, m.NDOObjectState, "Status wrong"); |
211 | ············IPersistenceCapable pc = pm.FindObject(id); |
212 | ············Assert.NotNull( pc, "There should be a hollow object." ); |
213 | ············Assert.AreEqual(NDOObjectState.Hollow, pc.NDOObjectState, "Status wrong"); |
214 | ········} |
215 | |
216 | ········[Test] |
217 | ········public void TestCleanupCache() |
218 | ········{ |
219 | ············pm.MakePersistent(m); |
220 | ············pm.CleanupCache(); |
221 | ············Assert.AreSame(m, pm.FindObject(m.NDOObjectId), "Getting same object twice should return same object"); |
222 | ············pm.Save(); |
223 | ············pm.CleanupCache(); |
224 | ············Assert.AreSame(m, pm.FindObject(m.NDOObjectId), "Getting same object twice should return same object"); |
225 | ············ObjectId id = m.NDOObjectId; |
226 | ············m = null; |
227 | ············pm.CleanupCache(); |
228 | ············Assert.NotNull(pm.FindObject(id), "Should find object"); |
229 | ········} |
230 | |
231 | ········[Test] |
232 | ········public void TestUnloadCache() |
233 | ········{ |
234 | ············pm.MakePersistent(m); |
235 | ············Assert.AreSame(m, pm.FindObject(m.NDOObjectId), "Getting same object twice should return same object"); |
236 | ············pm.Save(); |
237 | ············pm.UnloadCache(); |
238 | ············Assert.That(m != pm.FindObject(m.NDOObjectId), "Getting same object twice should return different objects"); |
239 | ············ObjectId id = m.NDOObjectId; |
240 | ············m = null; |
241 | ············pm.UnloadCache(); |
242 | ············Assert.NotNull(pm.FindObject(id), "Should find object"); |
243 | ········} |
244 | |
245 | ········[Test] |
246 | ········public void PmWithCachedMappingsWorks() |
247 | ········{ |
248 | ············PersistenceManager pm2 = new PersistenceManager( pm.NDOMapping ); |
249 | |
250 | ············pm2.MakePersistent( m ); |
251 | ············pm2.Save(); |
252 | ············pm2.UnloadCache(); |
253 | ············var m2 = pm2.Objects<Mitarbeiter>().First(); |
254 | |
255 | ············Assert.AreEqual( m.NDOObjectId, m2.NDOObjectId ); |
256 | ········} |
257 | |
258 | ········[Test] |
259 | ········public void TestClassExtent() |
260 | ········{ |
261 | ············ArrayList··mliste = new ArrayList(); |
262 | ············for(int i = 0; i < 100; i++) |
263 | ············{ |
264 | ················Mitarbeiter mm = CreateMitarbeiter("Hartmut", i.ToString()); |
265 | ················pm.MakePersistent(mm); |
266 | ················mliste.Add(mm); |
267 | ············} |
268 | |
269 | ············IList mitarbeiterListe = pm.GetClassExtent(typeof(Mitarbeiter)); |
270 | ············Assert.AreEqual(0, mitarbeiterListe.Count, "Current extent should be empty"); |
271 | ············pm.Save(); |
272 | |
273 | ············mitarbeiterListe = pm.GetClassExtent(typeof(Mitarbeiter)); |
274 | ············Assert.AreEqual(100, mitarbeiterListe.Count, "Number of read objects is wrong"); |
275 | ············// Check that all objects come from cache... |
276 | ············foreach(Mitarbeiter m1 in mitarbeiterListe) |
277 | ············{ |
278 | ················Assert.AreEqual(NDOObjectState.Persistent, m1.NDOObjectState, "Wrong state"); |
279 | ············} |
280 | |
281 | ············mliste.Clear(); |
282 | ············mliste = null; |
283 | ············mitarbeiterListe.Clear(); |
284 | ············mitarbeiterListe = null; |
285 | ············//pm.CleanupCache(); |
286 | ············pm.UnloadCache(); |
287 | ············mitarbeiterListe = pm.GetClassExtent(typeof(Mitarbeiter)); |
288 | ············Assert.AreEqual(100, mitarbeiterListe.Count, "Number of read objects is wrong"); |
289 | ············// Check that all objects are reloaded |
290 | ············foreach(Mitarbeiter m1 in mitarbeiterListe) |
291 | ············{ |
292 | ················Assert.AreEqual(NDOObjectState.Hollow, m1.NDOObjectState, "Wrong state"); |
293 | ············} |
294 | ········} |
295 | |
296 | |
297 | ········[Test] |
298 | ········public void TestMakePersistentHierarchy() |
299 | ········{ |
300 | ············Reisekosten.Email email = new Reisekosten.Email(); |
301 | ············m.Hinzufuegen(email); |
302 | ············email.Subject = new Reisekosten.Subject(); |
303 | ············email.Subject.Text = "Test"; |
304 | ············Assert.AreEqual(NDOObjectState.Transient, m.NDOObjectState, "Mitarbeiter muss transient sein"); |
305 | ············Assert.AreEqual(NDOObjectState.Transient, email.NDOObjectState, "Email muss transient sein"); |
306 | ············Assert.AreEqual(NDOObjectState.Transient, email.Subject.NDOObjectState, "Subject muss transient sein"); |
307 | ············pm.MakePersistent(m); |
308 | ············Assert.AreEqual(NDOObjectState.Created, m.NDOObjectState, "Mitarbeiter muss Created sein"); |
309 | ············Assert.AreEqual(NDOObjectState.Created, email.NDOObjectState, "Email muss Created sein"); |
310 | ············Assert.AreEqual(NDOObjectState.Created, email.Subject.NDOObjectState, "Subject muss Created sein"); |
311 | ············pm.Save(); |
312 | ············Assert.AreEqual(NDOObjectState.Persistent, m.NDOObjectState, "Mitarbeiter muss Persistent sein"); |
313 | ············Assert.AreEqual(NDOObjectState.Persistent, email.NDOObjectState, "Email muss Persistent sein"); |
314 | ············Assert.AreEqual(NDOObjectState.Persistent, email.Subject.NDOObjectState, "Subject muss Persistent sein"); |
315 | ············ |
316 | ········} |
317 | |
318 | ········[Test] |
319 | ········public void TestQuery() |
320 | ········{ |
321 | ············ArrayList··mliste = new ArrayList(); |
322 | ············for(int i = 1; i <= 100; i++) |
323 | ············{ |
324 | ················Mitarbeiter mm = CreateMitarbeiter("Hartmut", (i %··3)··== 0 ? "Test" : "xxx"); |
325 | ················pm.MakePersistent(mm); |
326 | ················mliste.Add(mm); |
327 | ············} |
328 | ············pm.Save();········ |
329 | |
330 | ············// Empty query: just like class extent. |
331 | ············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>(pm, null, true); |
332 | ············IList mitarbeiterListe = q.Execute(); |
333 | ············Assert.AreEqual(100, mitarbeiterListe.Count, "Number of read objects is wrong"); |
334 | |
335 | ············q = new NDOQuery<Mitarbeiter>(pm, "nachname = 'Test'", true); |
336 | ············//System.Diagnostics.Debug.WriteLine(q.GeneratedQuery); |
337 | ············mitarbeiterListe = q.Execute(); |
338 | ············Assert.AreEqual(100/3, mitarbeiterListe.Count, "Number of read objects is wrong"); |
339 | ········} |
340 | |
341 | ········[Test] |
342 | ········public void TestLinqQuery() |
343 | ········{ |
344 | ············ArrayList··mliste = new ArrayList(); |
345 | ············for(int i = 1; i <= 100; i++) |
346 | ············{ |
347 | ················Mitarbeiter mm = CreateMitarbeiter("Hartmut", (i % 3)··== 0 ? "Test" : "xxx"); |
348 | ················pm.MakePersistent(mm); |
349 | ················mliste.Add(mm); |
350 | ············} |
351 | ············pm.Save();········ |
352 | ············ |
353 | ············List<Mitarbeiter> mitarbeiterListe = from m in pm.Objects<Mitarbeiter>() select m; |
354 | |
355 | ············Assert.AreEqual(100, mitarbeiterListe.Count, "Number of read objects is wrong #1"); |
356 | |
357 | ············mitarbeiterListe = from m in pm.Objects<Mitarbeiter>() where m.Nachname == "Test" select m; |
358 | ············Assert.AreEqual(100/3, mitarbeiterListe.Count, "Number of read objects is wrong #2"); |
359 | |
360 | ············// Partial select |
361 | ············List<string> nameList = from m in pm.Objects<Mitarbeiter>() select m.Vorname; |
362 | |
363 | ············Assert.AreEqual(100, nameList.Count, "Number of read objects is wrong #3"); |
364 | |
365 | ············nameList = from m in pm.Objects<Mitarbeiter>() where m.Nachname == "Test" select m.Vorname; |
366 | ············Assert.AreEqual(100/3, mitarbeiterListe.Count, "Number of read objects is wrong #4"); |
367 | ········} |
368 | |
369 | ········[Test] |
370 | ········public void LinqQueryWithParameterWorks() |
371 | ········{ |
372 | ············pm.MakePersistent( m ); |
373 | ············pm.Save(); |
374 | ············Mitarbeiter m2 = Mitarbeiter.QueryByName(pm, "Hartmut"); |
375 | ············Assert.NotNull( m2 ); |
376 | ········} |
377 | |
378 | ········[Test] |
379 | ········public void LinqQueryWithNullParameterWorks() |
380 | ········{ |
381 | ············pm.MakePersistent( m ); |
382 | ············pm.Save(); |
383 | ············Mitarbeiter m2 = Mitarbeiter.QueryByName(pm, null); |
384 | ············Assert.IsNull( m2 ); |
385 | ········} |
386 | |
387 | ········[Test] |
388 | ········public void TestDeleteHollow() |
389 | ········{ |
390 | //············System.Diagnostics.Debug.WriteLine("TestDeleteHollow"); |
391 | ············pm.MakePersistent(m); |
392 | ············pm.Save(); |
393 | ············pm.UnloadCache(); |
394 | ············m = (Mitarbeiter)pm.FindObject(m.NDOObjectId); |
395 | ············Assert.AreEqual(NDOObjectState.Hollow, m.NDOObjectState, "Wrong state #1"); |
396 | ············pm.Delete(m); |
397 | ············Assert.AreEqual(NDOObjectState.Deleted, m.NDOObjectState, "Wrong state #2"); |
398 | ············pm.Abort(); |
399 | ············Assert.AreEqual(NDOObjectState.Persistent, m.NDOObjectState, "Wrong state #3"); |
400 | ············pm.UnloadCache(); |
401 | ············m = (Mitarbeiter)pm.FindObject(m.NDOObjectId); |
402 | ············Assert.AreEqual(NDOObjectState.Hollow, m.NDOObjectState, "Wrong state #4"); |
403 | ············pm.Delete(m); |
404 | ············pm.Save(); |
405 | ············Assert.AreEqual(NDOObjectState.Transient, m.NDOObjectState, "Wrong state #5"); |
406 | |
407 | ············IList l = pm.GetClassExtent(typeof(Mitarbeiter)); |
408 | ············Assert.AreEqual(0, l.Count, "Number of read objects is wrong"); |
409 | ········} |
410 | |
411 | ········[Test] |
412 | ········public void TestDeletePersistent() |
413 | ········{ |
414 | ············pm.MakePersistent(m); |
415 | ············pm.Save(); |
416 | ············pm.Delete(m); |
417 | ············Assert.AreEqual(NDOObjectState.Deleted, m.NDOObjectState, "Wrong state #1"); |
418 | ············IList l = pm.GetClassExtent(typeof(Mitarbeiter)); |
419 | ············Assert.AreEqual(1, l.Count, "Number of read objects is wrong"); |
420 | ············pm.Save(); |
421 | ············l = pm.GetClassExtent(typeof(Mitarbeiter)); |
422 | ············Assert.AreEqual(0, l.Count, "Number of read objects is wrong"); |
423 | ········} |
424 | |
425 | ········[Test] |
426 | ········public void TestDeletePersistentDirty() |
427 | ········{ |
428 | ············pm.MakePersistent(m); |
429 | ············pm.Save(); |
430 | ············m.Nachname = "Test"; |
431 | ············Assert.AreEqual(NDOObjectState.PersistentDirty, m.NDOObjectState, "Wrong state #1"); |
432 | ············pm.Delete(m); |
433 | ············Assert.AreEqual(NDOObjectState.Deleted, m.NDOObjectState, "Wrong state #1"); |
434 | ············pm.Abort(); |
435 | ············Assert.AreEqual("Kocher", m.Nachname, "Name shouldn't be changed"); |
436 | ············pm.Delete(m); |
437 | ············pm.Save(); |
438 | ············IList l = pm.GetClassExtent(typeof(Mitarbeiter)); |
439 | ············Assert.AreEqual(0, l.Count, "Number of read objects is wrong"); |
440 | ········} |
441 | |
442 | ········[Test] |
443 | ········public void TestPersistentDirty() |
444 | ········{ |
445 | ············pm.MakePersistent(m); |
446 | ············pm.Save(); |
447 | ············m.Nachname = "Test"; |
448 | ············Assert.AreEqual(NDOObjectState.PersistentDirty, m.NDOObjectState, "Wrong state #1"); |
449 | ············pm.Abort(); |
450 | ············Assert.AreEqual(NDOObjectState.Persistent, m.NDOObjectState, "Wrong state #2"); |
451 | ············Assert.AreEqual("Kocher", m.Nachname, "Name shouldn't be changed"); |
452 | ········} |
453 | |
454 | ········[Test] |
455 | ········public void TestMakeTransient() |
456 | ········{ |
457 | ············pm.MakePersistent(m); |
458 | ············pm.Save(); |
459 | ············ObjectId id = m.NDOObjectId; |
460 | ············pm.MakeTransient(m); |
461 | ············Assert.NotNull(id.Id, "MakeTransient shouldn't remove the ID");············ |
462 | ············Assert.Null( ((IPersistenceCapable)m).NDOStateManager, "Transient object shouldn't have state manager"); |
463 | ············Assert.AreEqual(NDOObjectState.Transient, m.NDOObjectState, "Wrong state #1"); |
464 | ············Assert.That(id.IsValid(), "Id should still be valid #1"); |
465 | ············m = (Mitarbeiter)pm.FindObject(id); |
466 | ············Assert.AreEqual(NDOObjectState.Hollow, m.NDOObjectState, "Wrong state #2"); |
467 | ············pm.MakeTransient(m); |
468 | ············Assert.Null( ((IPersistenceCapable)m).NDOStateManager, "Transient object shouldn't have state manager"); |
469 | ············Assert.AreEqual(NDOObjectState.Transient, m.NDOObjectState, "Wrong state #3"); |
470 | ············Assert.That(id.IsValid(), "Id should still be valid #2"); |
471 | ············m = (Mitarbeiter)pm.FindObject(id); |
472 | ············pm.Delete(m); |
473 | ············pm.Save(); |
474 | ············Assert.That(id.IsValid(), "Id should be valid for the ChangeLog"); |
475 | ········} |
476 | |
477 | ········[Test] |
478 | ········public void TestMakeHollow() |
479 | ········{ |
480 | ············pm.MakePersistent(m); |
481 | ············pm.Save(); |
482 | ············pm.MakeHollow(m); |
483 | ············Assert.AreEqual(NDOObjectState.Hollow, m.NDOObjectState, "Wrong state #1"); |
484 | ············string access = m.Nachname; |
485 | ············Assert.AreEqual(NDOObjectState.Persistent, m.NDOObjectState, "Wrong state #2"); |
486 | ············pm.MakeAllHollow(); |
487 | ············Assert.AreEqual(NDOObjectState.Hollow, m.NDOObjectState, "Wrong state #3"); |
488 | ········} |
489 | |
490 | ········[Test] |
491 | ········public void TestChangeHollow() |
492 | ········{ |
493 | ············pm.MakePersistent(m); |
494 | ············pm.Save(); |
495 | ············pm.MakeHollow(m); |
496 | ············m.Nachname = "Test"; |
497 | ············pm.Abort(); |
498 | ············Assert.AreEqual("Kocher", m.Nachname, "Name shouldn't be changed"); |
499 | ············pm.MakeHollow(m); |
500 | ············m.Nachname = "Test"; |
501 | ············pm.Save(); |
502 | ············Assert.AreEqual("Test", m.Nachname, "Name should be changed"); |
503 | ········} |
504 | |
505 | ········[Test] |
506 | ········public void TestRefreshFailed() |
507 | ········{ |
508 | ············bool thrown = false; |
509 | ············try |
510 | ············{ |
511 | ················pm.Refresh( m ); |
512 | ············} |
513 | ············catch (NDOException) |
514 | ············{ |
515 | ················thrown = true; |
516 | ············} |
517 | ············Assert.AreEqual( true, thrown ); |
518 | ········} |
519 | |
520 | ········[Test] |
521 | ········public void TestRefresh() |
522 | ········{ |
523 | ············pm.MakePersistent(m); |
524 | ············pm.Save(); |
525 | ············pm.MakeHollow(m); |
526 | ············pm.Refresh(m); |
527 | ············Assert.AreEqual(NDOObjectState.Persistent, m.NDOObjectState, "Wrong state #1"); |
528 | ············pm.Refresh(m); |
529 | ············Assert.AreEqual(NDOObjectState.Persistent, m.NDOObjectState, "Wrong state #2"); |
530 | ············ObjectId id = m.NDOObjectId; |
531 | |
532 | ············PersistenceManager pm2 = PmFactory.NewPersistenceManager(); |
533 | ············Mitarbeiter m2 = (Mitarbeiter)pm2.FindObject(id); |
534 | ············Assert.NotNull(m2, "Cannot load object"); |
535 | ············m2.Nachname = "Test"; |
536 | ············pm2.Save(); |
537 | ············pm2.Close(); |
538 | |
539 | ············Assert.AreEqual("Kocher", m.Nachname, "Wrong name #1"); |
540 | ············Assert.AreEqual("Test", m2.Nachname, "Wrong name #2"); |
541 | ············pm.Refresh(m); |
542 | ············Assert.AreEqual("Test", m.Nachname, "Wrong name #3"); |
543 | ········} |
544 | |
545 | ········[Test] |
546 | ········public void TestHollowMode() |
547 | ········{ |
548 | ············pm.MakePersistent(m); |
549 | ············pm.HollowMode = true; |
550 | ············pm.Save();············ |
551 | ············Assert.AreEqual(NDOObjectState.Hollow, m.NDOObjectState, "Wrong state #1"); |
552 | ············m.Nachname = "Test"; |
553 | ············pm.Abort(); |
554 | ············Assert.AreEqual(NDOObjectState.Hollow, m.NDOObjectState, "Wrong state #2"); |
555 | ············m.Nachname = "Test"; |
556 | ············pm.Save(); |
557 | ············Assert.AreEqual(NDOObjectState.Hollow, m.NDOObjectState, "Wrong state #3"); |
558 | ········} |
559 | |
560 | ········[Test] |
561 | ········public void TestAggregateQuery() |
562 | ········{ |
563 | ············Mitarbeiter mm; |
564 | ············IList l = new ArrayList(); |
565 | |
566 | ············for (int i = 0; i < 20; i++) |
567 | ············{ |
568 | ················mm = new Mitarbeiter(); |
569 | ················mm.Vorname = "lkj"; |
570 | ················mm.Nachname = i.ToString(); |
571 | ················mm.Position = new System.Drawing.Point(0, i); |
572 | ················pm.MakePersistent(mm); |
573 | ················l.Add(mm); |
574 | ············} |
575 | ············pm.Save(); |
576 | ············decimal sum = 0m;············ |
577 | ············foreach(Mitarbeiter m2 in l) |
578 | ············{ |
579 | ················sum += m2.Position.Y; |
580 | ············} |
581 | ············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>(pm, null); |
582 | ············decimal newsum = (decimal)q.ExecuteAggregate("position.Y", AggregateType.Sum); |
583 | ············Assert.AreEqual(sum, newsum, "Summe stimmt nicht"); |
584 | ············decimal count = (decimal)q.ExecuteAggregate("position.X", AggregateType.Count); |
585 | ············Assert.AreEqual(20, count, "Count stimmt nicht"); |
586 | ········} |
587 | |
588 | |
589 | ········[Test] |
590 | ········public void LinqTestAggregateQuery() |
591 | ········{ |
592 | ············Mitarbeiter mm; |
593 | ············var l = new List<Mitarbeiter>(); |
594 | |
595 | ············for (int i = 0; i < 20; i++) |
596 | ············{ |
597 | ················mm = new Mitarbeiter(); |
598 | ················mm.Vorname = "lkj"; |
599 | ················mm.Nachname = i.ToString(); |
600 | ················mm.Gehalt = 5000m + i * 100m; |
601 | ················pm.MakePersistent( mm ); |
602 | ················l.Add( mm ); |
603 | ············} |
604 | ············pm.Save(); |
605 | ············decimal sum = 0m; |
606 | ············foreach (Mitarbeiter m2 in l) |
607 | ············{ |
608 | ················sum += m2.Gehalt; |
609 | ············} |
610 | |
611 | ············decimal avg = sum / 20m; |
612 | |
613 | ············var virtualTable = pm.Objects<Mitarbeiter>(); |
614 | |
615 | ············decimal count = virtualTable.Count; |
616 | ············Assert.AreEqual( 20, count, "Count stimmt nicht" ); |
617 | |
618 | ············decimal newsum = virtualTable.Sum( m => m.Gehalt ); |
619 | ············Assert.AreEqual( sum, newsum, "Summe stimmt nicht" ); |
620 | |
621 | ············decimal newavg = virtualTable.Average( m => m.Gehalt ); |
622 | ············Assert.AreEqual( avg, newavg, "Durchschnitt stimmt nicht" ); |
623 | ········} |
624 | |
625 | |
626 | ········[Test] |
627 | ········public void TestPolymorphicQuery() |
628 | ········{ |
629 | ············// If two classes are mapped to the same table, the query |
630 | ············// should give us the class which is given as parameter |
631 | |
632 | ············pm.MakePersistent(m); // Manager with privilegstufe 0 |
633 | ············pm.Save(); |
634 | ············pm.UnloadCache(); |
635 | ············IQuery q = new NDOQuery<Mitarbeiter>(pm, null); |
636 | ············IList l = q.Execute(); |
637 | ············Assert.AreEqual(1, l.Count, "Only one object should be returned"); |
638 | ············Assert.AreEqual(typeof(Mitarbeiter), l[0].GetType(), "Object should be a Mitarbeiter"); |
639 | |
640 | ············// Fetch the same object as manager |
641 | ············q = new NDOQuery<Manager>(pm, null); |
642 | ············l = q.Execute(); |
643 | ············Assert.AreEqual(1, l.Count, "Only one object should be returned"); |
644 | ············Assert.AreEqual(typeof(Manager), l[0].GetType(), "Object should be a Manager"); |
645 | ········} |
646 | |
647 | ········[Test] |
648 | ········public void TestStringLen() |
649 | ········{ |
650 | ············string s = string.Empty; |
651 | ············for (int i = 0; i < 255; i++) |
652 | ············{ |
653 | ················s += "A"; |
654 | ············} |
655 | ············m.Vorname = s; |
656 | ············pm.MakePersistent(m); |
657 | ············pm.Save(); |
658 | ············pm.UnloadCache(); |
659 | ············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>(pm); |
660 | ············Mitarbeiter m2 = (Mitarbeiter) q.ExecuteSingle(true); |
661 | ············Assert.AreEqual(255, m2.Vorname.Length, "Lönge des Vornamens falsch"); |
662 | ········} |
663 | |
664 | |
665 | ········[Test] |
666 | ········public void TestHollowDelete() |
667 | ········{ |
668 | ············pm.MakePersistent(m); |
669 | ············pm.Save(); |
670 | ············pm.UnloadCache(); |
671 | ············// Load hollow |
672 | ············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>(pm, null, true); |
673 | ············IList l = q.Execute(); |
674 | ············Assert.AreEqual(1, l.Count, "Anzahl Mitarbeiter falsch #1"); |
675 | ············pm.Delete(l); |
676 | ············pm.Save(); |
677 | ············pm.UnloadCache(); |
678 | ············q = new NDOQuery<Mitarbeiter>(pm); |
679 | ············l = q.Execute(); |
680 | ············Assert.AreEqual(0, l.Count, "Anzahl Mitarbeiter falsch #2"); |
681 | |
682 | ········} |
683 | |
684 | ········[Test] |
685 | ········public void TestHollowDelete2Pm() |
686 | ········{ |
687 | ············pm.MakePersistent(m); |
688 | ············pm.Save(); |
689 | ············pm.UnloadCache(); |
690 | ············// Load hollow |
691 | ············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>(pm, null, true); |
692 | ············IList l = q.Execute(); |
693 | ············Assert.AreEqual(1, l.Count, "Anzahl Mitarbeiter falsch #1"); |
694 | ············PersistenceManager pm2 = PmFactory.NewPersistenceManager(); |
695 | ············pm2.Delete(l); |
696 | ············pm2.Save(); |
697 | ············q = new NDOQuery<Mitarbeiter>(pm); |
698 | ············l = q.Execute(); |
699 | ············Assert.AreEqual(0, l.Count, "Anzahl Mitarbeiter falsch #2"); |
700 | ········} |
701 | |
702 | |
703 | //········[Test] |
704 | //········void TestVerboseMode() |
705 | //········{ |
706 | //············PersistenceManager pm = new PersistenceManager(); |
707 | // |
708 | //············pm.MakePersistent(m); |
709 | //············pm.Save(); |
710 | // |
711 | //············m.Vorname = "Hallo"; |
712 | // |
713 | //············m.NDOStateManager.PersistenceManager.LogPath = "C:\\Temp"; |
714 | //············Assert.AreEqual(m.NDOStateManager.PersistenceManager.LogPath, pm.LogPath, "LogPath falsch"); |
715 | //············if (File.Exists(pm.LogFile)) |
716 | //················.... |
717 | //············m.NDOStateManager.PersistenceManager.VerboseMode = true; |
718 | //········ |
719 | //············m.NDOStateManager.PersistenceManager.Save();···· |
720 | //········} |
721 | |
722 | |
723 | ········[Test] |
724 | ········public void Angriff() |
725 | ········{ |
726 | //············pm.MakePersistent(m); |
727 | //············pm.Save(); |
728 | ············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>(pm, "nachname LIKE {0}"); |
729 | ············q.Parameters.Add("dummy';SELECT * from Mitarbeiter; --"); |
730 | ············IList l = q.Execute(); |
731 | ········} |
732 | |
733 | ········[Test] |
734 | ········public void LoadDataOnUnknownObjectThrows() |
735 | ········{ |
736 | ············Mitarbeiter m = (Mitarbeiter)pm.FindObject( typeof( Mitarbeiter ), 1000000 ); |
737 | ············bool thrown = false; |
738 | ············try |
739 | ············{ |
740 | ················pm.LoadData( m ); |
741 | ············} |
742 | ············catch (NDOException ex) |
743 | ············{ |
744 | ················Assert.AreEqual( 72, ex.ErrorNumber ); |
745 | ················thrown = true; |
746 | ············} |
747 | |
748 | ············Assert.That( thrown ); |
749 | ········} |
750 | |
751 | ········[Test] |
752 | ········public void LoadDataOnUnknownObjectCallsEventHandler() |
753 | ········{ |
754 | ············pm.ObjectNotPresentEvent += ea => true;··// prevents throwing an exception |
755 | ············Mitarbeiter m = (Mitarbeiter)pm.FindObject( typeof( Mitarbeiter ), 1000000 ); |
756 | ············pm.LoadData( m ); |
757 | ········} |
758 | |
759 | ········[Test] |
760 | ········public void LoadDataReturnsPersistentObject() |
761 | ········{ |
762 | ············pm.MakePersistent( m ); |
763 | ············var oid = m.NDOObjectId; |
764 | ············pm.Save(); |
765 | ············pm.UnloadCache(); |
766 | ············var m2 = pm.FindObject( oid ); |
767 | ············Assert.AreEqual( NDOObjectState.Hollow, m2.NDOObjectState ); |
768 | ············pm.LoadData( m2 ); |
769 | ············Assert.AreEqual( NDOObjectState.Persistent, m2.NDOObjectState ); |
770 | ········} |
771 | |
772 | ········[Test] |
773 | ········public void CanQueryWithInClause() |
774 | ········{ |
775 | ············var pm = PmFactory.NewPersistenceManager(); |
776 | ············var m1 = CreateMitarbeiter("Mirko", "Matytschak"); |
777 | ············var m2 = CreateMitarbeiter("Hans", "Huber"); |
778 | ············pm.MakePersistent( m1 ); |
779 | ············pm.MakePersistent( m2 ); |
780 | ············pm.Save(); |
781 | ············pm.UnloadCache(); |
782 | ············var l = pm.Objects<Mitarbeiter>().Where(m=>m.Vorname.In(new []{ "Mirko" } )).ResultTable; |
783 | ············Assert.AreEqual( 1, l.Count ); |
784 | ············l = pm.Objects<Mitarbeiter>().Where(m=>m.Vorname.In(new []{ "Mirko", "Hans" } )).ResultTable; |
785 | ············Assert.AreEqual( 2, l.Count ); |
786 | ············Assert.AreEqual( 0, QueryByGuid( new[] { Guid.NewGuid() } ).Count ); |
787 | ········} |
788 | |
789 | ········List<Mitarbeiter> QueryByGuid(Guid[] guids) |
790 | ········{ |
791 | ············return pm.Objects<Mitarbeiter>().Where( m => m.Vorname.In( guids ) ); |
792 | ········} |
793 | |
794 | ········[Test] |
795 | ········public void CanInsertObjectsUsingSqlHandler() |
796 | ········{ |
797 | ············var pm = PmFactory.NewPersistenceManager(); |
798 | ············pm.TransactionMode = TransactionMode.None; |
799 | ············using (var handler = pm.GetSqlPassThroughHandler()) |
800 | ············{ |
801 | ················var sql = "INSERT INTO [Mitarbeiter] ([Vorname],[Nachname],[Gehalt]) VALUES (@p0, @p1, @p2)"; |
802 | ················handler.Execute( sql, false, "Fritz", "Müller", 123456.34m ); |
803 | ············} |
804 | ············var m = pm.Objects<Mitarbeiter>().SingleOrDefault(); |
805 | ············Assert.NotNull( m ); |
806 | ············Assert.AreEqual( "Fritz", m.Vorname ); |
807 | ············Assert.AreEqual( "Müller", m.Nachname ); |
808 | ············Assert.AreEqual( 123456.34m, m.Gehalt ); |
809 | ········} |
810 | |
811 | ········[Test] |
812 | ········public void CanInsertObjectsWithNullParameterUsingSqlHandler() |
813 | ········{ |
814 | ············var pm = PmFactory.NewPersistenceManager(); |
815 | ············pm.TransactionMode = TransactionMode.None; |
816 | ············using (var handler = pm.GetSqlPassThroughHandler()) |
817 | ············{ |
818 | ················var sql = "INSERT INTO [Mitarbeiter] ([Vorname],[Nachname],[Gehalt]) VALUES (@p0, @p1, @p2)"; |
819 | ················handler.Execute( sql, false, null, "Müller", 123456.34m ); |
820 | ············} |
821 | ············var m = pm.Objects<Mitarbeiter>().SingleOrDefault(); |
822 | ············Assert.NotNull( m ); |
823 | ············Assert.AreEqual( "Müller", m.Nachname ); |
824 | ············Assert.AreEqual( 123456.34m, m.Gehalt ); |
825 | ········} |
826 | |
827 | ········[Test] |
828 | ········public void CanPerformDirectDelete() |
829 | ········{ |
830 | ············pm.MakePersistent( m ); |
831 | ············pm.Save(); |
832 | ············var firstName = m.Vorname; |
833 | |
834 | ············Assert.IsTrue( pm.Objects<Mitarbeiter>().Where( m => m.Vorname == firstName ).Count > 0 ); |
835 | |
836 | ············var q = new NDOQuery<Mitarbeiter>( pm, "vorname = {0}" ); |
837 | ············q.Parameters.Add( firstName ); |
838 | ············q.DeleteDirectly(); |
839 | |
840 | ············Assert.AreEqual( 0, pm.Objects<Mitarbeiter>().Where( m => m.Vorname == firstName ).Count ); |
841 | |
842 | ············m = CreateMitarbeiter( "Mirko", "Matytschak" ); |
843 | ············pm.MakePersistent( m ); |
844 | ············pm.Save(); |
845 | ············firstName = m.Vorname; |
846 | |
847 | ············Assert.IsTrue( pm.Objects<Mitarbeiter>().Where( m => m.Vorname == firstName ).Count > 0 ); |
848 | |
849 | ············pm.Objects<Mitarbeiter>().Where( m => m.Vorname == firstName ).DeleteDirectly(); |
850 | |
851 | ············Assert.AreEqual( 0, pm.Objects<Mitarbeiter>().Where( m => m.Vorname == firstName ).Count ); |
852 | ········} |
853 | |
854 | ········private Mitarbeiter CreateMitarbeiter(string vorname, string nachname) |
855 | ········{ |
856 | ············Mitarbeiter m = new Mitarbeiter(); |
857 | ············m.Vorname = vorname; |
858 | ············m.Nachname = nachname; |
859 | ············return m; |
860 | ········} |
861 | ····} |
862 | } |
863 |