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