Datei: IntegrationTests/IntegrationTests/NDOMitarbeiterTests.cs

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