Datei: IntegrationTests/IntegrationTests/NDOMitarbeiterReiseTests.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.Collections;
27	using System.Collections.Generic;
28	using NUnit.Framework;
29	using NDO;
30	using NDO.Query;
31	using Reisekosten;
32	using Reisekosten.Personal;
33	using NDO.Linq;
34	using NDO.Mapping;

35
36	namespace NdoUnitTests
37	{
38	····/// <summary>
39	····/// Combined Tests of Mitarbeiter and Reise to test uniqueness of object ids.
40	····/// </summary>
41	····[TestFixture]
42	public class NDOMitarbeiterReiseTests
43	····{
44	········public NDOMitarbeiterReiseTests()
45	········{
46	········}
47
48	········private PersistenceManager pm;
49	········private Mitarbeiter m;
50	········private Reise r;
51
52	········[SetUp]
53	········public void Setup() {
54	············pm = PmFactory.NewPersistenceManager();
55	············m = CreateMitarbeiter("Hartmut", "Kocher");
56	············r = CreateReise("ADC");
57	········}
58
59	········[TearDown]
60	········public void TearDown() {
61	············pm.Abort();
62	············pm.UnloadCache();
63	IList mitarbeiterListe = pm. GetClassExtent( typeof( Mitarbeiter) , true) ;
64	············pm.Delete(mitarbeiterListe);
65	············pm.Save();

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

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.Collections;
27	using System.Collections.Generic;
28	using NUnit.Framework;
29	using NDO;
30	using NDO.Query;
31	using Reisekosten;
32	using Reisekosten.Personal;
33	using NDO.Linq;
34	using NDO.Mapping;
35	using Microsoft.Extensions.DependencyInjection;
36
37	namespace NdoUnitTests
38	{
39	····/// <summary>
40	····/// Combined Tests of Mitarbeiter and Reise to test uniqueness of object ids.
41	····/// </summary>
42	····[TestFixture]
43	public class NDOMitarbeiterReiseTests : NDOTest
44	····{
45	········public NDOMitarbeiterReiseTests()
46	········{
47	········}
48
49	········private PersistenceManager pm;
50	········private Mitarbeiter m;
51	········private Reise r;
52
53	········[SetUp]
54	········public void Setup() {
55	············pm = PmFactory.NewPersistenceManager();
56	············m = CreateMitarbeiter("Hartmut", "Kocher");
57	············r = CreateReise("ADC");
58	········}
59
60	········[TearDown]
61	········public void TearDown() {
62	············pm.Abort();
63	············pm.UnloadCache();
64	var mitarbeiterListe = pm. Objects<Mitarbeiter>( ) . ResultTable;
65	············pm.Delete(mitarbeiterListe);
66	············pm.Save();
67	············pm.Objects<Reise>().DeleteDirectly();
68	············pm.Close();

69	············pm.Dispose();
70	········}
71
72	········[Test]
73	········public void TestCreateObjects() {
74	············pm.MakePersistent(m);
75	············pm.MakePersistent(r);
76	············Assert.That(!m.NDOObjectId.Equals(r.NDOObjectId), "Ids should be different");
77	············m = (Mitarbeiter)pm.FindObject(m.NDOObjectId);
78	············r = (Reise)pm.FindObject(r.NDOObjectId);
79	········}
80
81	········[Test]
82	········public void TestCreateObjectsSave() {
83	············m.Hinzufuegen(r);
84	············pm.MakePersistent(m);
85	············pm.Save();
86	············Assert.That(!m.NDOObjectId.Equals(r.NDOObjectId), "Ids should be different");
87	············m = (Mitarbeiter)pm.FindObject(m.NDOObjectId);
88	············r = (Reise)pm.FindObject(r.NDOObjectId);
89	············Assert.That(m != null, "1. Mitarbeiter not found");
90	············Assert.That(r != null, "1. Reise not found");
91
92	············pm.UnloadCache();
93	············m = (Mitarbeiter)pm.FindObject(m.NDOObjectId);
94	············r = (Reise)pm.FindObject(r.NDOObjectId);
95	············Assert.That(m != null, "2. Mitarbeiter not found");
96	············Assert.That(r != null, "2. Reise not found");
97	········}
98
99	········[Test]
100	········public void TestAddObjectSave() {
101	············pm.MakePersistent(m);
102	············pm.Save();
103	············m.Hinzufuegen(r);
104	············Assert.That(NDOObjectState.Created ==··r.NDOObjectState, "1. Wrong state");
105	············pm.Save();
106	············m = (Mitarbeiter)pm.FindObject(m.NDOObjectId);
107	············r = (Reise)pm.FindObject(r.NDOObjectId);
108	············Assert.That(m != null, "1. Mitarbeiter not found");
109	············Assert.That(r != null, "1. Reise not found");
110	············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "2. Wrong state");
111	········}
112
113	········int GetOrdinal(Relation r)
114	········{
115	············var t = r.Parent.SystemType;
116	············Type mcType = t.GetNestedType( "MetaClass", BindingFlags.NonPublic \| BindingFlags.Public );
117	············if (null == mcType)
118	················throw new NDOException( 13, "Missing nested class 'MetaClass' for type '" + t.Name + "'; the type doesn't seem to be enhanced." );
119	············var mc = (IMetaClass2)Activator.CreateInstance( mcType, t );
120	············return mc.GetRelationOrdinal( r.FieldName );
121	········}
122
123	········bool IsLoaded(IPersistentObject pc, Relation r)
124	········{
125	············return ((IPersistenceCapable)pc).NDOLoadState.RelationLoadState[GetOrdinal( r )];
126	········}
127
128	········[Test]
129	········public void RestorePreservesRelationLists()
130	········{
131	············pm.MakePersistent( m );
132	············pm.Save();
133	············m.Hinzufuegen( r );
134	············pm.Save();
135	············Assert.That(1 ==··m.Reisen.Count );
136
137	············pm.UnloadCache();
138	············var m2 = pm.Objects<Mitarbeiter>().Single();
139
140	············var relation = pm.NDOMapping.FindClass( typeof( Mitarbeiter ) ).FindRelation( "dieReisen" );
141
142	············Assert.That( !IsLoaded( m2, relation ) );
143	············var list = m2.Reisen;
144	············m2.Vorname = "Testxxxx";
145
146	············Assert.That( IsLoaded( m2, relation ) );
147
148	············pm.Restore( m2 );
149	············m2.Nachname = "Testyyyy";
150	············pm.Save();
151
152
153	············Assert.That(1 ==··m2.Reisen.Count );
154	········}
155
156	········[Test]
157	········public void TestAddObjectAbort() {
158	············pm.MakePersistent(m);
159	············pm.Save();
160	············m.Hinzufuegen(r);
161	············Assert.That(NDOObjectState.Created ==··r.NDOObjectState, "1. Wrong state");
162	············Assert.That(1 ==··m.Reisen.Count, "1. Wrong number of objects");
163	············pm.Abort();
164	············Assert.That(NDOObjectState.Transient ==··r.NDOObjectState, "2. Wrong state");
165	············Assert.That(0 ==··m.Reisen.Count, "2. Wrong number of objects");
166	········}
167	········[Test]
168	········public void TestRemoveObjectSave() {
169	············pm.MakePersistent(m);
170	············m.Hinzufuegen(r);
171	············pm.Save();
172	············Assert.That(1 ==··m.Reisen.Count, "1. Wrong number of objects");
173	············m.Löschen(r);
174	············Assert.That(NDOObjectState.Deleted ==··r.NDOObjectState, "1. Wrong state");
175	············Assert.That(0 ==··m.Reisen.Count, "2. Wrong number of objects");
176	············pm.Save();
177	············Assert.That(0 ==··m.Reisen.Count, "3. Wrong number of objects");
178	············Assert.That(NDOObjectState.Transient ==··r.NDOObjectState, "2. Wrong state");
179	········}
180	············
181	········[Test]
182	········public void TestRemoveObjectAbort() {
183	············pm.MakePersistent(m);
184	············m.Hinzufuegen(r);
185	············pm.Save();
186	············Assert.That(1 ==··m.Reisen.Count, "1. Wrong number of objects");
187	············m.Löschen(r);
188	············Assert.That(NDOObjectState.Deleted ==··r.NDOObjectState, "1. Wrong state");
189	············Assert.That(0 ==··m.Reisen.Count, "2. Wrong number of objects");
190	············pm.Abort();
191	············Assert.That(1 ==··m.Reisen.Count, "3. Wrong number of objects");
192	············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "2. Wrong state");
193	········}
194
195	········[Test]
196	········public void TestDeleteSave() {
197	············pm.MakePersistent(m);
198	············m.Hinzufuegen(r);
199	············pm.Save();
200	············pm.Delete(m);
201	············Assert.That(NDOObjectState.Deleted ==··m.NDOObjectState, "1. Wrong state");
202	············Assert.That(NDOObjectState.Deleted ==··r.NDOObjectState, "2. Wrong state");
203	············pm.Save();
204	············Assert.That(NDOObjectState.Transient ==··m.NDOObjectState, "1. Wrong state");
205	············Assert.That(NDOObjectState.Transient ==··r.NDOObjectState, "2. Wrong state");
206	········}
207
208
209
210	········[Test]
211	········public void TestDeleteAbort() {
212	············pm.MakePersistent(m);
213	············m.Hinzufuegen(r);
214	············pm.Save();
215	············pm.Delete(m);
216	············Assert.That(NDOObjectState.Deleted ==··m.NDOObjectState, "1. Wrong state");
217	············Assert.That(NDOObjectState.Deleted ==··r.NDOObjectState, "2. Wrong state");
218	············pm.Abort();
219	············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "1. Wrong state");
220	············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "2. Wrong state");
221	········}
222
223	········[Test]
224	········public void TestAddRemoveSave() {
225	············pm.MakePersistent(m);
226	············pm.Save();
227	············m.Hinzufuegen(r);
228	············m.Löschen(r);
229	············Assert.That(NDOObjectState.Transient ==··r.NDOObjectState, "1. Wrong state");
230	············pm.Save();
231	············Assert.That(NDOObjectState.Transient ==··r.NDOObjectState, "2. Wrong state");
232	········}
233
234	········[Test]
235	········public void TestAddRemoveAbort() {
236	············pm.MakePersistent(m);
237	············pm.Save();
238	············m.Hinzufuegen(r);
239	············m.Löschen(r);
240	············Assert.That(NDOObjectState.Transient ==··r.NDOObjectState, "1. Wrong state");
241	············pm.Abort();
242	············Assert.That(NDOObjectState.Transient ==··r.NDOObjectState, "2. Wrong state");
243	········}
244
245	········[Test]
246	········public void TestClearRelatedObjectsSave() {
247	············for(int i = 0; i < 10; i++) {
248	················m.Hinzufuegen(CreateReise(i.ToString()));
249	············}
250	············pm.MakePersistent(m);
251	············pm.Save();
252	············IList rr = new ArrayList(m.Reisen);
253	············m.LöscheReisen();
254	············Assert.That(0 ==··m.Reisen.Count, "1. Wrong number of objects");
255	············for(int i = 0; i < 10; i++) {
256	················Assert.That(NDOObjectState.Deleted ==··((Reise)rr[i]).NDOObjectState, "2. Wrong state");
257	············}
258	············pm.Save();
259	············Assert.That(0 ==··m.Reisen.Count, "3. Wrong number of objects");
260	············for(int i = 0; i < 10; i++) {
261	················Assert.That(NDOObjectState.Transient ==··((Reise)rr[i]).NDOObjectState, "4. Wrong state");
262	············}
263	········}
264
265	········[Test]
266	········public void TestClearRelatedObjectsAbort() {
267	············for(int i = 0; i < 10; i++) {
268	················m.Hinzufuegen(CreateReise(i.ToString()));
269	············}
270	············pm.MakePersistent(m);
271	············pm.Save();
272	············IList rr = new ArrayList(m.Reisen);
273	············m.LöscheReisen();
274	············Assert.That(0 ==··m.Reisen.Count, "1. Wrong number of objects");
275	············for(int i = 0; i < 10; i++) {
276	················Assert.That(NDOObjectState.Deleted ==··((Reise)rr[i]).NDOObjectState, "2. Wrong state");
277	············}
278	············pm.Abort();
279	············Assert.That(10 ==··m.Reisen.Count, "3. Wrong number of objects");
280	············for(int i = 0; i < 10; i++) {
281	················Assert.That(NDOObjectState.Persistent ==··((Reise)rr[i]).NDOObjectState, "4. Wrong state");
282	············}
283	········}
284
285	········[Test]
286	········public void TestAssignRelatedObjectsNullSave() {
287	············for(int i = 0; i < 3; i++) {
288	················m.Hinzufuegen(CreateReise(i.ToString()));
289	············}
290	············pm.MakePersistent(m);
291	············pm.Save();
292	············IList rr = new ArrayList(m.Reisen);
293	············m.ErsetzeReisen(null);
294	············Assert.That(m.Reisen == null, "No objects should be there");
295	············for(int i = 0; i < 3; i++) {
296	················Assert.That(NDOObjectState.Deleted ==··((Reise)rr[i]).NDOObjectState, "2. Wrong state");
297	············}
298	············pm.Save();
299	············Assert.That(m.Reisen == null, "No objects should be there");
300	············for(int i = 0; i < 3; i++) {
301	················Assert.That(NDOObjectState.Transient ==··((Reise)rr[i]).NDOObjectState, "4. Wrong state");
302	············}
303	········}
304
305	········[Test]
306	········public void TestAssignRelatedObjectsNullAbort() {
307	············for(int i = 0; i < 3; i++) {
308	················m.Hinzufuegen(CreateReise(i.ToString()));
309	············}
310	············pm.MakePersistent(m);
311	············pm.Save();
312	············IList rr = new ArrayList(m.Reisen);
313	············m.ErsetzeReisen(null);
314	············Assert.That(m.Reisen == null, "No objects should be there");
315	············for(int i = 0; i < 3; i++) {
316	················Assert.That(NDOObjectState.Deleted ==··((Reise)rr[i]).NDOObjectState, "2. Wrong state");
317	············}
318	············pm.Abort();
319	············Assert.That(3 ==··m.Reisen.Count, "3. Wrong number of objects");
320	············for(int i = 0; i < 3; i++) {
321	················Assert.That(NDOObjectState.Persistent ==··((Reise)rr[i]).NDOObjectState, "4. Wrong state");
322	············}
323	········}
324
325	········[Test]
326	········public void TestAssignRelatedObjectsSave() {
327	············for(int i = 0; i < 3; i++) {
328	················m.Hinzufuegen(CreateReise(i.ToString()));
329	············}
330	············pm.MakePersistent(m);
331	············pm.Save();
332	············IList neueReisen = new ArrayList();
333	············Reise nr = CreateReise("Test");
334	············neueReisen.Add(nr);
335
336	············IList rr = new ArrayList(m.Reisen);
337	············m.ErsetzeReisen(neueReisen);
338	············Assert.That(1 ==··m.Reisen.Count, "1. Wrong number of objects");
339	············for(int i = 0; i < 3; i++) {
340	················Assert.That(NDOObjectState.Deleted ==··((Reise)rr[i]).NDOObjectState, "2. Wrong state");
341	············}
342	············Assert.That(NDOObjectState.Created ==··nr.NDOObjectState, "3. Wrong state");
343
344	············pm.Save();
345	············Assert.That(1 ==··m.Reisen.Count, "4. Wrong number of objects");
346	············for(int i = 0; i < 3; i++) {
347	················Assert.That(NDOObjectState.Transient ==··((Reise)rr[i]).NDOObjectState, "5. Wrong state");
348	············}
349	············Assert.That(NDOObjectState.Persistent ==··nr.NDOObjectState, "6. Wrong state");
350	········}
351
352	········[Test]
353	········public void TestAssignRelatedObjectsAbort() {
354	············for(int i = 0; i < 3; i++) {
355	················m.Hinzufuegen(CreateReise(i.ToString()));
356	············}
357	············pm.MakePersistent(m);
358	············pm.Save();
359	············IList neueReisen = new ArrayList();
360	············Reise nr = CreateReise("Test");
361	············neueReisen.Add(nr);
362
363	············IList rr = new ArrayList(m.Reisen);
364	············m.ErsetzeReisen(neueReisen);
365	············Assert.That(1 ==··m.Reisen.Count, "1. Wrong number of objects");
366	············for(int i = 0; i < 3; i++) {
367	················Assert.That(NDOObjectState.Deleted ==··((Reise)rr[i]).NDOObjectState, "2. Wrong state");
368	············}
369	············Assert.That(NDOObjectState.Created ==··nr.NDOObjectState, "3. Wrong state");
370
371	············pm.Abort();
372	············Assert.That(3 ==··m.Reisen.Count, "4. Wrong number of objects");
373	············for(int i = 0; i < 3; i++) {
374	················Assert.That(NDOObjectState.Persistent ==··((Reise)rr[i]).NDOObjectState, "5. Wrong state");
375	············}
376	············Assert.That(NDOObjectState.Transient ==··nr.NDOObjectState, "6. Wrong state");
377	········}
378
379	········[Test]
380	········public void TestAddNewReise()
381	········{
382	············m.Hinzufuegen(r);
383	············pm.MakePersistent(m);
384	············pm.Save();
385	············pm.UnloadCache();
386	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>(pm);
387	············m = q.ExecuteSingle(true);
388	············Reise r2 = CreateReise("Schnulli");
389	············m.Hinzufuegen(r2);
390	············pm.Save();
391	············m = q.ExecuteSingle(true);
392	············Assert.That(2 ==··m.Reisen.Count, "Count wrong");
393	········}
394
395	········[Test]
396	········public void RefreshReloadsRelation()
397	········{
398	············m.Hinzufuegen( r );
399	············pm.MakePersistent( m );
400	············pm.Save();
401	············PersistenceManager pm2 = PmFactory.NewPersistenceManager();
402	············Mitarbeiter m2 = pm2.Objects<Mitarbeiter>().ResultTable.First();
403	············Assert.That(m.Reisen.Count ==··m2.Reisen.Count );
404	············Assert.That(1 ==··m.Reisen.Count );
405	············Reise r2 = new Reise() { Zweck = "Test" };
406	············m2.Hinzufuegen( r2 );
407	············pm2.Save();
408	············Assert.That(1 ==··m.Reisen.Count );
409	············pm.Refresh( m );
410	············Assert.That(2 ==··m.Reisen.Count );
411	········}
412
413	········[Test]
414	········public void CanIterateThrougRelatedObjectsWithLinq()
415	········{
416	············m.Hinzufuegen( r );
417	············r = new Reise() { Zweck = "Test" };
418	············m.Hinzufuegen( r );
419	············pm.MakePersistent( m );
420	············pm.Save();
421	············Assert.That(2 ==··m.Reisen.Count );
422	············ObjectId oid = m.NDOObjectId;
423	············pm.UnloadCache();
424	············pm = PmFactory.NewPersistenceManager();
425	············m = (Mitarbeiter) pm.FindObject( oid );
426	············Assert.That( m.NDOObjectState == NDOObjectState.Hollow );
427	············Reise tr = (from reise in m.Reisen where reise.Zweck == "Test" select reise).SingleOrDefault();
428	············Assert.That(tr··!= null);
429	············Assert.That("Test" ==··tr.Zweck );
430	········}
431
432	········[Test]
433	········public void TestHollow() {
434	············m.Hinzufuegen(r);
435	············pm.MakePersistent(m);
436	············pm.Save();
437	············pm.MakeHollow(m);
438	············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "1: Mitarbeiter should be hollow");
439	············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "1: Reise should be persistent");
440	············IList reise = m.Reisen;
441
442	············pm.MakeHollow(m, true);
443	············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "2: Mitarbeiter should be hollow");
444	············Assert.That(NDOObjectState.Hollow ==··r.NDOObjectState, "2: Reise should be hollow");
445
446	············reise = m.Reisen;
447	············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "3: Mitarbeiter should be persistent");
448	············Assert.That(NDOObjectState.Hollow ==··r.NDOObjectState, "3: Reise should be hollow");
449	············Assert.That("ADC" ==··r.Zweck, "3: Reise should have correct Zweck");
450	············Assert.That(NDOObjectState.Persistent ==··r.NDOObjectState, "4: Reise should be persistent");
451	········}
452
453	········[Test]
454	········public void··TestMakeAllHollow() {
455	············m.Hinzufuegen(r);
456	············pm.MakePersistent(m);
457	············pm.Save();
458	············pm.MakeAllHollow();
459	············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "1: Mitarbeiter should be hollow");
460	············Assert.That(NDOObjectState.Hollow ==··r.NDOObjectState, "1: Reise should be hollow");
461	············pm.UnloadCache();
462	········}
463
464	········[Test]
465	········public void··TestMakeAllHollowUnsaved() {
466	············m.Hinzufuegen(r);
467	············pm.MakePersistent(m);
468	············pm.MakeAllHollow();··// before save, objects cannot be made hollow. => in locked objects
469	············Assert.That(NDOObjectState.Created ==··m.NDOObjectState, "1: Mitarbeiter should be created");
470	············Assert.That(NDOObjectState.Created ==··r.NDOObjectState, "1: Reise should be created");
471	········}
472
473	········[Test]
474	········public void TestLoadRelatedObjects() {
475	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>(pm, null);
476	············IList dellist = q.Execute();
477	············pm.Delete(dellist);
478	············pm.Save();
479	············pm.UnloadCache();
480
481	············for(int i = 0; i < 10; i++) {
482	················m.Hinzufuegen(CreateReise(i.ToString()));
483	············}
484	············pm.MakePersistent(m);
485	············pm.Save();
486	············pm.MakeHollow(m, true);
487
488	············IList reisen = new ArrayList(m.Reisen);
489	············Assert.That(10 ==··reisen.Count, "Array size should be 10");
490
491	············for(int i = 0; i < 10; i++) {
492	················Reise rr = (Reise)reisen[i];
493	················Assert.That(NDOObjectState.Hollow ==··rr.NDOObjectState, "1: Reise should be hollow");
494	//················if (i.ToString()!= rr.Zweck)
495	//················{
496	//····················for (int j = 0; j < 10; j++)
497	//························System.Diagnostics.Debug.WriteLine("Reise: " + ((Reise)reisen[j]).Zweck);
498	//················}
499	#if !ORACLE && !MYSQL && !FIREBIRD
500	················if (rr.NDOObjectId.Id[0] is Int32)
501	····················Assert.That(i.ToString() ==··rr.Zweck, "2: Reise should be in right order");
502	#endif
503	············}
504
505
506	············pm.MakeAllHollow();
507	············pm.UnloadCache();
508	············IList reisen2 = m.Reisen;
509	············for(int i = 0; i < 10; i++) {
510	················Reise r1 = (Reise)reisen[i];
511	················Reise r2 = (Reise)reisen2[i];
512	#if !ORACLE && !MYSQL && !FIREBIRD
513	················if (r1.NDOObjectId.Id[0] is Int32)
514	················Assert.That(i.ToString() ==··r1.Zweck, "3: Reise should be in right order");
515	#endif
516	················Assert.That(r1 !=··r2, "Objects should be different");
517	············}
518	········}
519
520	········[Test]
521	········public void TestLoadRelatedObjectsSave() {
522	············pm.MakePersistent(m);
523	············pm.Save();
524	············for(int i = 0; i < 10; i++) {
525	················m.Hinzufuegen(CreateReise(i.ToString()));
526	············}
527	············pm.Save();
528	············pm.MakeHollow(m, true);
529
530	············IList reisen = new ArrayList(m.Reisen);
531
532	············for(int i = 0; i < 10; i++) {
533	················Reise rr = (Reise)reisen[i];
534	················Assert.That(NDOObjectState.Hollow ==··rr.NDOObjectState, "1: Reise should be hollow");
535	#if !ORACLE && !MYSQL && !FIREBIRD
536	················if (rr.NDOObjectId.Id[0] is Int32)
537	····················Assert.That(i.ToString() ==··rr.Zweck, "2: Reise should be in right order");
538	#endif
539	············}
540
541
542	············pm.MakeAllHollow();
543	············pm.UnloadCache();
544	············IList reisen2 = m.Reisen;
545	············for(int i = 0; i < 10; i++) {
546	················Reise r1 = (Reise)reisen[i];
547	················Reise r2 = (Reise)reisen2[i];
548	#if !ORACLE && !MYSQL && !FIREBIRD
549	················if (r1.NDOObjectId.Id[0] is Int32)
550	················Assert.That(i.ToString() ==··r1.Zweck, "3: Reise should be in right order");
551	#endif
552	················Assert.That(r1 !=··r2, "Objects should be different");
553	············}
554	········}
555
556	········[Test]
557	········public void TestExtentRelatedObjects() {
558	············m.Hinzufuegen(r);
559	············pm.MakePersistent(m);
560	············pm.Save();
561	············IList liste = pm.GetClassExtent(typeof(Mitarbeiter));
562	············m = (Mitarbeiter)liste[0];
563	············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "1: Mitarbeiter should be persistent");
564	············Assert.That(m.Reisen != null, "2. Relation is missing");
565	············Assert.That(1 ==··m.Reisen.Count, "3. Wrong number of objects");
566	············Assert.That(NDOObjectState.Persistent ==··((Reise)m.Reisen[0]).NDOObjectState, "4.: Reise should be hollow");
567
568	············pm.UnloadCache();
569	············liste = pm.GetClassExtent(typeof(Mitarbeiter));
570	············m = (Mitarbeiter)liste[0];
571	············Assert.That(NDOObjectState.Hollow ==··m.NDOObjectState, "5: Mitarbeiter should be hollow");
572	············Assert.That(m.Reisen != null, "6. Relation is missing");
573	············Assert.That(1 ==··m.Reisen.Count, "7. Wrong number of objects");
574	············Assert.That(NDOObjectState.Hollow ==··((Reise)m.Reisen[0]).NDOObjectState, "8.: Reise should be hollow");
575
576	············pm.UnloadCache();
577	············liste = pm.GetClassExtent(typeof(Mitarbeiter), false);
578	············m = (Mitarbeiter)liste[0];
579	············Assert.That(NDOObjectState.Persistent ==··m.NDOObjectState, "9: Mitarbeiter should be persistent");
580	············Assert.That(m.Reisen != null, "10. Relation is missing");
581	············Assert.That(1 ==··m.Reisen.Count, "11. Wrong number of objects");
582	············Assert.That(NDOObjectState.Hollow ==··((Reise)m.Reisen[0]).NDOObjectState, "12.: Reise should be hollow");
583	········}
584
585	········[Test]
586	········public void TestReiseChangeReload()
587	········{
588	············m.Hinzufuegen(r);
589	············pm.MakePersistent(m);
590	············pm.Save();
591	············pm.UnloadCache();
592	············var provider = pm.NDOMapping.FindClass( typeof( Reise ) ).Provider;
593	············NDOQuery<Reise> q = new NDOQuery<Reise>(pm, $"zweck LIKE 'A{provider.Wildcard}'");
594	············r = (Reise) q.ExecuteSingle(true);
595	············r.Zweck = "NewPurpose";

596	············pm.Save();

597	············NDOQuery<Mitarbeiter> qm = new NDOQuery<Mitarbeiter>(pm);
598	············m = qm.ExecuteSingle(true);
599	············Assert.That(1 ==··m.Reisen.Count, "Count wrong");
600	············Assert.That("NewPurpose" ==··r.Zweck, "Reise wrong");
601	········}
602
603	········[Test]
604	········public void RelationEmptyAssignment()
605	········{
606	············m.Hinzufuegen(r);
607	············pm.MakePersistent(m);
608	············pm.Save();
609	············pm.UnloadCache();
610	············m = (Mitarbeiter) pm.FindObject(m.NDOObjectId);
611	············//Assert.That(m.Reisen.Count == 1);
612	············m.ErsetzeReisen(new ArrayList());
613	············pm.Save();
614	············pm.UnloadCache();
615	//············// This code gets the same result
616	//············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>(pm, "oid = {0}");
617	//············q.Parameters.Add(m.NDOObjectId.Id.Value);
618	//············m = (Mitarbeiter) q.ExecuteSingle(true);
619
620	············m = (Mitarbeiter) pm.FindObject(m.NDOObjectId);
621	············Assert.That(m.Reisen.Count == 0, "Reisen should be empty");
622	········}
623
624	········[Test]
625	········public void RelationNullAssignment()
626	········{
627	············m.Hinzufuegen(r);
628	············pm.MakePersistent(m);
629	············pm.Save();
630	············pm.UnloadCache();
631	············m = (Mitarbeiter) pm.FindObject(m.NDOObjectId);
632	············//Assert.That(m.Reisen.Count == 1);
633	············m.ErsetzeReisen(null);
634	············pm.Save();
635	············pm.UnloadCache();
636	············m = (Mitarbeiter) pm.FindObject(m.NDOObjectId);
637	············Assert.That(m.Reisen.Count == 0, "Reisen should be empty");
638	········}
639
640	········[Test]
641	[Ignore( "persistenceHandler doesn't exist anymore") ]
642	········public void AbortedTransaction()
643	········{
644	············m.Hinzufuegen( r );
645	············pm.MakePersistent( m );
646	············pm.Save();
647	············pm.UnloadCache();
648
649	············pm.TransactionMode = TransactionMode.Optimistic;
650
651	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm, null );
652	············m = (Mitarbeiter)q.ExecuteSingle( true );
653	············m.Vorname = "Hans";
654	············((Reise)m.Reisen[0]).Zweck = "Neuer Zweck";
655
656	············FieldInfo fi = pm.NDOMapping.GetType().GetField( "persistenceHandler", BindingFlags.Instance \| BindingFlags.NonPublic );
657
658	············Dictionary<Type, IPersistenceHandler> ht = (Dictionary<Type, IPersistenceHandler>)fi.GetValue( pm.NDOMapping );
659	············ht.Clear();
660	············pm.NDOMapping.FindClass( typeof( Reise ) ).FindField( "zweck" ).Column.Name = "nix";
661
662	············try
663	············{
664	················pm.Save();
665	············}
666	············catch
667	············{
668	················ht.Clear();
669	················pm.NDOMapping.FindClass( typeof( Reise ) ).FindField( "zweck" ).Column.Name = "Zweck";
670	················pm.Abort();
671	············}
672
673	············pm.UnloadCache();
674	············m = (Mitarbeiter)q.ExecuteSingle( true );
675	············Assert.That("Hartmut" ==··m.Vorname, "Vorname falsch" );
676	············Assert.That("ADC" ==··((Reise)m.Reisen[0]).Zweck, "Vorname falsch" );
677	········}
678
679	········[Test]
680	········public void ResolveTest()
681	········{
682	············// This makes sure, that each resolve delivers a new PersistenceHandler.
683	var h1 = Host. Services. GetRequiredService<IPersistenceHandler>( ) ;
684	var h2 = Host. Services. GetRequiredService<IPersistenceHandler>( ) ;
685	············Assert.That( !object.ReferenceEquals( h1, h2 ) );
686	········}
687
688	········[Test]
689	········public void TestListEnumerator()
690	········{
691	············m.Hinzufuegen(r);
692	············pm.MakePersistent(m);
693	············pm.Save();
694	············pm.UnloadCache();
695	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>(pm, null);
696	············m = (Mitarbeiter) q.ExecuteSingle(true);
697	············IEnumerator ie = m.Reisen.GetEnumerator();
698	············bool result = ie.MoveNext();
699	············Assert.That(result, "Enumerator should give a result");
700	············Assert.That(ie.Current != null);
701	········}
702
703	········[Test]
704	········public void TestListCount()
705	········{
706	············m.Hinzufuegen(r);
707	············pm.MakePersistent(m);
708	············pm.Save();
709	············pm.UnloadCache();
710	············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>(pm, null);
711	············m = (Mitarbeiter) q.ExecuteSingle(true);
712	············Assert.That(1 ==··m.Reisen.Count, "Count should be 1");
713	········}
714
715	········[Test]
716	········public void TestLinqQuery()
717	········{
718	············m.Hinzufuegen(r);
719	············pm.MakePersistent(m);
720	············pm.Save();
721	············pm.UnloadCache();
722	············m = (from mi in pm.Objects<Mitarbeiter>() where mi.Reisen[Any.Index].Zweck == "ADC" select mi).FirstOrDefault();
723	············Assert.That(m != null, "There should be 1 object");
724	············Assert.That(1 ==··m.Reisen.Count, "Count should be 1");
725	········}
726
727
728	········private Mitarbeiter CreateMitarbeiter(string vorname, string nachname)
729	········{
730	············Mitarbeiter m = new Mitarbeiter();
731	············m.Vorname = vorname;
732	············m.Nachname = nachname;
733	············return m;
734	········}
735
736	········private Reise CreateReise(string zweck) {
737	············Reise r = new Reise();
738	············r.Zweck = zweck;
739	············return r;
740	········}
741	····}
742	}
743

Cookie Info