Datei: NdoJsonFormatter/FormatterUnitTests/Tests.cs

Last Commit (1814d4b)
1 //
2 // Copyright (c) 2002-2024 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 using NDO.JsonFormatter;
 
 
 
 
23 using NUnit.Framework;
24 using System;
25 using System.Linq;
26 using Reisekosten;
27 using Reisekosten.Personal;
28 using NDO;
29 using System.IO;
30 using Newtonsoft. Json;
31 using Newtonsoft.Json.Linq;
32 using NDOInterfaces;
33
34 namespace FormatterUnitTests
35 {
36 ····[TestFixture]
37 ····public class Tests
38 ····{
39 ········PersistenceManager pm;
 
40
41 ········[SetUp]
42 ········public void SetUp()
43 ········{
 
44 ············this.pm = new PersistenceManager();
45 ········}
46
47 ········[TearDown]
48 ········public void TearDown()
49 ········{
50 ············var ml = this.pm.Objects<Mitarbeiter>().ResultTable;
51 ············this.pm.Delete( ml );
52 ············this.pm.Save();
53
54 ············var rl = this.pm.Objects<Reise>().ResultTable;
55 ············this.pm.Delete(rl);
56 ············this.pm.Save();
57
58 ············var ll = this.pm.Objects<Land>().ResultTable;
59 ············this.pm.Delete(ll);
60 ············this.pm.Save();
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
61
 
 
 
 
62 ········}
 
63
64 ········Mitarbeiter CreatePersistentMitarbeiter()
65 ········{
66 ············Mitarbeiter m = new Mitarbeiter();
67 ············m.Vorname = "Mirko";
68 ············m.Nachname = "Matytschak";
69 ············pm.MakePersistent( m );
70 ············pm.Save();
71 ············var objectId = m.NDOObjectId;
72 ············pm.UnloadCache();
73 ············m = (Mitarbeiter)this.pm.FindObject( objectId );
74 ············return m;
75 ········}
76
77 ········Mitarbeiter CreateMitarbeiterWithTravelAndAddress()
78 ········{
79 ············Mitarbeiter m = new Mitarbeiter();
80 ············m.Vorname = "Mirko";
81 ············m.Nachname = "Matytschak";
82 ············pm.MakePersistent( m );
83 ············m.Hinzufuegen( new Reise { Zweck = "Vortrag" } );
84 ············m.Adresse = new Adresse { Lkz = "D", Plz = "84149", Straße = "Ahornstr. 5", Ort="Eberspoint" };
85 ············pm.Save();
86 ············var objectId = m.NDOObjectId;
87 ············pm.UnloadCache();
88 ············m = (Mitarbeiter) this.pm.FindObject( objectId );
89 ············return m;
90 ········}
91
92 ········private Mitarbeiter CreateMitarbeiter()
93 ········{
94 ············Mitarbeiter m = new Mitarbeiter();
95 ············m.Vorname = "Mirko";
96 ············m.Nachname = "Matytschak";
97 ············m.Position = new System.Drawing.Point( 111, 222 );
98 ············return m;
99 ········}
100
101 ········[Test]
102 ········public void CanSerializeObject()
103 ········{
104 ············NdoJsonFormatter formatter = new NdoJsonFormatter(this.pm);
105 ············var m = CreatePersistentMitarbeiter();
106 ············Assert.That( m··!= null);
107 ············var ms = new MemoryStream();
108 ············formatter.Serialize( ms, m );
109 ············ms.Seek( 0L, SeekOrigin.Begin );
110 ············string json = null;
111 ············using (StreamReader sr = new StreamReader( ms ))
112 ············{
113 ················json = sr.ReadToEnd();
114 ············}
115
116 ············Assert.That( json··!= null);
117 ········}
118
119 ········[Test]
120 ········public void CanGetObjectContainer()
121 ········{
122 ············CreateObjectContainer();
123 ········}
124
125 ········private string CreateObjectContainer(bool serializeAddress = false)
126 ········{
127 ············NdoJsonFormatter formatter = new NdoJsonFormatter();
128 ············Mitarbeiter user = CreateMitarbeiterWithTravelAndAddress();
129 ············Assert.That( user··!= null);
130 ············var relations = serializeAddress ? new string[] { "dieReisen", "adresse" } : new string[]{"dieReisen"};
131 ············ObjectContainer container = new ObjectContainer(r=>relations.Contains( r.FieldName ));
132 ············container.AddObject( user );
133
134 ············var ms = new MemoryStream();
135 ············container.Serialize( ms, formatter );
136 ············ms.Seek( 0L, SeekOrigin.Begin );
137 ············string json = null;
138 ············using (StreamReader sr = new StreamReader( ms ))
139 ············{
140 ················json = sr.ReadToEnd();
141 ············}
142
143 ············Assert.That( json··!= null );
144 ············var jObj = JsonConvert.DeserializeObject<JObject>(json);
145 ············var rootObjects = (JArray)jObj["rootObjects"];
146 ············var additionalObjects = (JArray)jObj["additionalObjects"];
147 ············Assert.That( rootObjects··!= null);
148 ············Assert.That( additionalObjects··!= null);
149 ············Assert.That( 1 == rootObjects.Count() );
150 ············Assert.That( (serializeAddress ? 2 : 1) == additionalObjects.Count() );
151 ············var rootObject = rootObjects[0];
152 ············Assert.That( ( (string) rootObject["_oid"] ).StartsWith( "Mitarbeiter-F33D0A6D" ) );
153 ············return json;
154 ········}
155
156 ········[Test]
157 ········[TestCase(true)]
158 ········[TestCase( false )]
159 ········public void CanDeserializeObjectContainer(bool serializeAddress)
160 ········{
161 ············ObjectContainer oc = new ObjectContainer();
162 ············string json = CreateObjectContainer(serializeAddress);
163 ············this.pm = new PersistenceManager();
164 ············oc.Deserialize( json, new NdoJsonFormatter(this.pm) );
165 ············Assert.That( 1 == oc.RootObjects.Count );
166 ············Assert.That( oc.RootObjects[0] is Mitarbeiter );
167 ············Mitarbeiter m = (Mitarbeiter)oc.RootObjects[0];
168 ············Assert.That( "Mirko" == m.Vorname );
169 ············Assert.That( 1 == m.Reisen.Count );
170 ············if (serializeAddress)
171 ············{
172 ················Assert.That( m.Adresse··!= null);
173 ················Assert.That( "D" == m.Adresse.Lkz );
174 ············}
175 ············else
176 ············{
177 ················Assert.That( m.Adresse··== null );
178 ············}
179 ········}
180
181 ········[Test]
182 ········[TestCase(typeof(NdoJsonFormatter))]
183 ········public void ObjectContainerIsSerializable(Type formatterType)
184 ········{
185 ············INdoFormatter formatter = (INdoFormatter)Activator.CreateInstance(formatterType);
186
187 ············var m = CreateMitarbeiter();
188 ············pm.MakePersistent( m );
189 ············pm.Save();
190 ············var oc = pm.GetObjectContainer();
191 ············Assert.That( Object.ReferenceEquals( m, oc.RootObjects[0] ) );
192
193 ············oc.Formatter = formatter;
194 ············string serialized = oc.MarshalingString;
195
196 ············pm.UnloadCache();
197
198 ············var oc2 = pm.GetObjectContainer();
199 ············Assert.That( 0 == oc2.RootObjects.Count );
200
201 ············oc = new ObjectContainer();
202 ············oc.Deserialize( serialized, formatter );
203 ············pm.MergeObjectContainer( oc );
204
205 ············oc2 = pm.GetObjectContainer();
206 ············Assert.That( 1 == oc2.RootObjects.Count );
207
208 ············m = (Mitarbeiter) oc2.RootObjects[0];
209 ············Assert.That( "Mirko" == m.Vorname );
210 ············Assert.That( NDOObjectState.Persistent == m.NDOObjectState );
211 ········}
212
213
214 ········[Test]
215 ········[TestCase(typeof(NdoJsonFormatter))]
216 ········public void ChangeRelationWithExistingObject(Type formatterType)
217 ········{
218 ············// Create object and serialize it
219 ············INdoFormatter formatter = (INdoFormatter)Activator.CreateInstance(formatterType);
220
221 ············var r = new Reise { Zweck = "NDO" };
222 ············pm.MakePersistent(r);
223 ············var l = new Land("Germany");
224 ············pm.MakePersistent(l);
225 ············pm.Save();
226 ············var oc = pm.GetObjectContainer();
227
228 ············oc.Formatter = formatter;
229 ············string serialized = oc.MarshalingString;
230
231 ············pm.UnloadCache();
232
233 ············// Merge object in to an OfflinePersistenceManager and change it
234 ············OfflinePersistenceManager opm = new OfflinePersistenceManager(pm.NDOMapping.FileName);
235
236 ············oc = new ObjectContainer();
237 ············oc.Deserialize(serialized, formatter);
238
239 ············opm.MergeObjectContainer(oc);
240
241 ············var newOc = oc.RootObjects.Cast<IPersistenceCapable>();
242 ············var r2 = (Reise)newOc.FirstOrDefault(pc=>pc is Reise);
243 ············var l2 = (Land)newOc.FirstOrDefault(pc => pc is Land); ;
244 ············Assert.That( NDOObjectState.Persistent == r2.NDOObjectState);
245 ············Assert.That( NDOObjectState.Persistent == l2.NDOObjectState);
246 ············r2.LandHinzufügen(l2);
247 ············Assert.That( NDOObjectState.PersistentDirty == r2.NDOObjectState);
248
249 ············// Create a ChangeSetContainer and serialize it
250 ············var csc = opm.GetChangeSet();
251 ············csc.Formatter = formatter;
252 ············string serializedChanges = csc.MarshalingString;
253
254 ············// Merge the changes back to pm
255 ············csc = new ChangeSetContainer();
256 ············csc.Deserialize(serializedChanges, formatter);
257 ············r = (Reise)csc.ChangedObjects.Cast<IPersistenceCapable>().FirstOrDefault(pc => pc is Reise);
258 ············pm.MergeObjectContainer(csc);
259 ············r2 = (Reise)pm.FindObject(r.NDOObjectId);
260 ············Assert.That( NDOObjectState.PersistentDirty == r2.NDOObjectState);
261 ············Assert.That( 1 == r2.Länder.Count);
262
263 ············// Save and Reload
264 ············pm.Save();
265 ············pm.UnloadCache();
266 ············r = pm.Objects<Reise>().Single();
267 ············Assert.That( 1 == r2.Länder.Count);
268 ········}
269
270
271 ········[Test]
272 ········[TestCase(typeof(NdoJsonFormatter))]
273 ········public void ChangeRelationWithNewObject(Type formatterType)
274 ········{
275 ············// Create object and serialize it
276 ············INdoFormatter formatter = (INdoFormatter)Activator.CreateInstance(formatterType);
277
278 ············var m = CreateMitarbeiter();
279 ············pm.MakePersistent(m);
280 ············pm.Save();
281 ············var oc = pm.GetObjectContainer();
282
283 ············oc.Formatter = formatter;
284 ············string serialized = oc.MarshalingString;
285
286 ············pm.UnloadCache();
287
288 ············// Merge object in to an OfflinePersistenceManager and change it
289 ············OfflinePersistenceManager opm = new OfflinePersistenceManager(pm.NDOMapping.FileName);
290
291 ············oc = new ObjectContainer();
292 ············oc.Deserialize(serialized, formatter);
293
294 ············opm.MergeObjectContainer(oc);
295
296 ············var m2 = (Mitarbeiter)oc.RootObjects[0];
297 ············Assert.That( NDOObjectState.Persistent == m2.NDOObjectState);
298 ············m2.Hinzufuegen(new Reise() { Zweck = "NDO" });············
299 ············Assert.That( NDOObjectState.PersistentDirty == m2.NDOObjectState);
300
301 ············// Create a ChangeSetContainer and serialize it
302 ············var csc = opm.GetChangeSet();
303 ············csc.Formatter = formatter;
304 ············string serializedChanges = csc.MarshalingString;
305
306 ············// Merge the changes back to pm
307 ············csc = new ChangeSetContainer();
308 ············csc.Deserialize(serializedChanges, formatter);
309 ············m = (Mitarbeiter)csc.ChangedObjects[0];
310 ············pm.MergeObjectContainer(csc);
311 ············m2 = (Mitarbeiter)pm.FindObject(m.NDOObjectId);
312 ············Assert.That( NDOObjectState.PersistentDirty == m2.NDOObjectState);
313 ············Assert.That( 1 == m2.Reisen.Count);
314
315 ············// Save and Reload
316 ············pm.Save();
317 ············pm.UnloadCache();
318 ············m = pm.Objects<Mitarbeiter>().Single();
319 ············Assert.That( 1 == m2.Reisen.Count);
320 ········}
321
322 ········[Test]
323 ········[TestCase(typeof(NdoJsonFormatter))]
324 ········public void CompleteTurnaroundWithChangeSetContainer(Type formatterType)
325 ········{
326 ············// Create object and serialize it
327 ············INdoFormatter formatter = (INdoFormatter)Activator.CreateInstance(formatterType);
328
329 ············var m = CreateMitarbeiter();
330 ············pm.MakePersistent( m );
331 ············pm.Save();
332 ············var oc = pm.GetObjectContainer();
333
334 ············oc.Formatter = formatter;
335 ············string serialized = oc.MarshalingString;
336
337 ············pm.UnloadCache();
338
339 ············// Merge object in to an OfflinePersistenceManager and change it
340 ············OfflinePersistenceManager opm = new OfflinePersistenceManager( pm.NDOMapping.FileName );
341
342 ············oc = new ObjectContainer();
343 ············oc.Deserialize( serialized, formatter );
344
345 ············opm.MergeObjectContainer( oc );
346
347 ············var m2 = (Mitarbeiter)oc.RootObjects[0];
348 ············Assert.That( NDOObjectState.Persistent == m2.NDOObjectState );
349 ············m2.Vorname = "Hans";
350 ············Assert.That( NDOObjectState.PersistentDirty == m2.NDOObjectState );
351
352 ············// Create a ChangeSetContainer and serialize it
353 ············var csc = opm.GetChangeSet();
354 ············csc.Formatter = formatter;
355 ············string serializedChanges = csc.MarshalingString;
356
357 ············// Merge the changes back to pm
358 ············csc = new ChangeSetContainer();
359 ············csc.Deserialize( serializedChanges, formatter );
360 ············m = (Mitarbeiter) csc.ChangedObjects[0];
361 ············pm.MergeObjectContainer( csc );
362 ············m2 = (Mitarbeiter) pm.FindObject( m.NDOObjectId );
363 ············Assert.That( NDOObjectState.PersistentDirty == m2.NDOObjectState );
364 ············Assert.That( "Hans" == m.Vorname );
365
366 ············// Save and Reload
367 ············pm.Save();
368 ············pm.UnloadCache();
369 ············m = pm.Objects<Mitarbeiter>().Single();
370 ············Assert.That( "Hans" == m.Vorname );
371 ········}
372
373 ········[Test]
374 ········[TestCase(typeof(NdoJsonFormatter))]
375 ········public void CompleteTurnaroundWithAddedObject(Type formatterType)
376 ········{
377 ············// Create object and serialize it
378 ············INdoFormatter formatter = (INdoFormatter)Activator.CreateInstance(formatterType);
379
380 ············var m = CreateMitarbeiter();
381 ············pm.MakePersistent(m);
382 ············pm.Save();
383 ············var oc = pm.GetObjectContainer();
384
385 ············oc.Formatter = formatter;
386 ············string serialized = oc.MarshalingString;
387
388 ············pm.UnloadCache();
389
390 ············// Merge object into an OfflinePersistenceManager and change it
391 ············OfflinePersistenceManager opm = new OfflinePersistenceManager(pm.NDOMapping.FileName);
392
393 ············oc = new ObjectContainer();
394 ············oc.Deserialize(serialized, formatter);
395
396 ············opm.MergeObjectContainer(oc);
397
398 ············var m2 = new Mitarbeiter() { Vorname = "Hans", Nachname = "Müller" };
399 ············opm.MakePersistent(m2);
400
401 ············// Create a ChangeSetContainer and serialize it
402 ············var csc = opm.GetChangeSet();
403 ············csc.Formatter = formatter;
404 ············string serializedChanges = csc.MarshalingString;
405
406 ············// Merge the changes back to pm
407 ············csc = new ChangeSetContainer();
408 ············csc.Deserialize(serializedChanges, formatter);
409
410 ············Assert.That(csc.AddedObjects.Count == 1);
411
412 ············pm = new PersistenceManager();··// we need a new pm here which get's us id's beginning from -1
413 ············pm.MergeObjectContainer(csc);
414 ············// Now we should have a created object in the cache
415 ············Assert.That( true == pm.HasChanges);
416 ············m = (Mitarbeiter)pm.FindObject(typeof(Mitarbeiter), -1);
417 ············Assert.That(m.NDOObjectState == NDOObjectState.Created);
418
419 ············// Save and Reload
420 ············pm.Save();
421 ············Assert.That(m.NDOObjectState == NDOObjectState.Persistent);
422 ············pm.UnloadCache();
423 ············var l = pm.Objects<Mitarbeiter>().ResultTable;
424 ············Assert.That( 2 == l.Count);
425 ············Assert.That(l.Any(m1 => m1.Vorname == "Mirko" && m1.Nachname == "Matytschak"));
426 ············Assert.That(l.Any(m1 => m1.Vorname == "Hans" && m1.Nachname == "Müller"));
427 ········}
428
429 ········[Test]
430 ········public void CanSetObjectsToHollow()
431 ········{
432 ············var formatter = new NdoJsonFormatter();
433 ············var serializationIterator = new NDO.SerializationIterator( r => r.ReferencedType == typeof( Reise ), pc => pc.NDOObjectState = NDOObjectState.Hollow );
434
435 ············var m = CreateMitarbeiter();
436 ············pm.MakePersistent( m );
437 ············Reise reise;
438 ············m.Hinzufuegen( reise = new Reise() { Zweck = "NDO" } );
439 ············pm.Save();
440
441 ············var oc = pm.GetObjectContainer();
442 ············oc.SerialisationIterator = serializationIterator;
443
444 ············bool found = false;
445 ············foreach (object o in oc.RootObjects)
446 ············{
447 ················if (Object.ReferenceEquals( m, o ))
448 ····················found = true;
449 ············}
450 ············Assert.That( found );
451
452 ············Assert.That( NDOObjectState.Persistent == m.NDOObjectState );
453
454 ············oc.Formatter = formatter;
455 ············string serialized = oc.MarshalingString;
456
457 ············Assert.That( 2 == oc.RootObjects.Count );
458 ············Assert.That( NDOObjectState.Hollow == m.NDOObjectState );
459 ············Assert.That( NDOObjectState.Hollow == reise.NDOObjectState );
460 ········}
461
462 ········[Test]
463 ········[TestCase(typeof(NdoJsonFormatter))]
464 ········public void ObjectContainerSerializesRelations(Type formatterType)
465 ········{
466 ············INdoFormatter formatter = (INdoFormatter)Activator.CreateInstance(formatterType);
467 ············var serializationIterator = new NDO.SerializationIterator( r => r.ReferencedType == typeof( Reise ) );
468
469 ············var m = CreateMitarbeiter();
470 ············pm.MakePersistent( m );
471 ············m.Hinzufuegen( new Reise() { Zweck = "NDO" } );
472 ············pm.Save();
473
474 ············var oc = pm.GetObjectContainer();
475
476 ············bool found = false;
477 ············foreach (object o in oc.RootObjects)
478 ············{
479 ················if (Object.ReferenceEquals( m, o ))
480 ····················found = true;
481 ············}
482 ············Assert.That( found );
483
484 ············oc.SerialisationIterator = serializationIterator;
485 ············oc.Formatter = formatter;
486 ············string serialized = oc.MarshalingString;
487
488 ············Assert.That( 2 == oc.RootObjects.Count );
489
490 ············pm.UnloadCache();
491
492 ············var oc2 = pm.GetObjectContainer();
493 ············Assert.That( 0 == oc2.RootObjects.Count );
494
495 ············oc = new ObjectContainer();
496 ············oc.Deserialize( serialized, formatter );
497 ············pm.MergeObjectContainer( oc );
498
499 ············oc2 = pm.GetObjectContainer();
500 ············Assert.That( 2 == oc2.RootObjects.Count );
501
502 ············Reise r2 = null;
503 ············Mitarbeiter m2 = null;
504
505 ············foreach (object o in oc2.RootObjects)
506 ············{
507 ················if (o is Reise)
508 ····················r2 = (Reise) o;
509 ················if (o is Mitarbeiter)
510 ····················m2 = (Mitarbeiter) o;
511 ············}
512
513 ············Assert.That( r2··!= null);
514 ············Assert.That( m2··!= null);
515
516 ············Assert.That( "Mirko" == m2.Vorname );
517 ············Assert.That( NDOObjectState.Persistent == m2.NDOObjectState );
518
519 ············Assert.That( "NDO" == r2.Zweck );
520 ············Assert.That( NDOObjectState.Persistent == r2.NDOObjectState );
521 ········}
522 ········[Test]
523 ········public void TestJsonNull()
524 ········{
525 ············var formatter = new NdoJsonFormatter(this.pm);
526 ············MemoryStream ms = new MemoryStream();
527 ············StreamWriter sw = new StreamWriter(ms);
528 ············sw.Write("null");
529 ············ms.Position = 0;
530
531 ············object obj = formatter.Deserialize(ms);
532 ············Assert.That( obj == null );
533 ········}
534
535 ····}
536 }
537
New Commit (182cfd7)
1 //
2 // Copyright (c) 2002-2024 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 using Microsoft.Extensions.DependencyInjection;
23 using Microsoft.Extensions.Hosting;
24 using Microsoft.Extensions.Logging;
25 using NDO;
26 using NDO.Application;
27 using NDO.JsonFormatter;
28 using NDO.SqlPersistenceHandling;
29 using NDOInterfaces;
30 using Newtonsoft.Json;
31 using Newtonsoft.Json.Linq;
32 using NUnit.Framework;
 
 
33 using Reisekosten;
34 using Reisekosten.Personal;
35 using System;
36 using System.IO;
37 using System. Linq;
 
 
38
39 namespace FormatterUnitTests
40 {
41 ····[TestFixture]
42 ····public class Tests
43 ····{
44 ········PersistenceManager pm;
45 ········IServiceProvider serviceProvider;
46
47 ········[SetUp]
48 ········public void SetUp()
49 ········{
50 ············Build();
51 ············this.pm = new PersistenceManager();
52 ········}
53
54 ········[TearDown]
55 ········public void TearDown()
56 ········{
57 ············var ml = this.pm.Objects<Mitarbeiter>().ResultTable;
58 ············this.pm.Delete( ml );
59 ············this.pm.Save();
60
61 ············var rl = this.pm.Objects<Reise>().ResultTable;
62 ············this.pm.Delete(rl);
63 ············this.pm.Save();
64
65 ············var ll = this.pm.Objects<Land>().ResultTable;
66 ············this.pm.Delete(ll);
67 ············this.pm.Save();
68
69 ········}
70
71 ········void Build( Action<IServiceCollection> configure = null )
72 ········{
73 ············var builder = Host.CreateDefaultBuilder();
74 ············builder.ConfigureServices( services =>
75 ············{
76 ················services.AddLogging( b =>
77 ················{
78 ····················b.ClearProviders();
79 ····················b.AddConsole();
80 ················} );
81
82 ················services.AddNdo( null, null );
83 ················if (configure != null)
84 ····················configure( services );
85 ············} );
86
87 ············var host = builder.Build();
88 ············this.serviceProvider = host.Services;
89 ············host.Services.UseNdo();
90
91 ········}
92
93
94 ········Mitarbeiter CreatePersistentMitarbeiter()
95 ········{
96 ············Mitarbeiter m = new Mitarbeiter();
97 ············m.Vorname = "Mirko";
98 ············m.Nachname = "Matytschak";
99 ············pm.MakePersistent( m );
100 ············pm.Save();
101 ············var objectId = m.NDOObjectId;
102 ············pm.UnloadCache();
103 ············m = (Mitarbeiter)this.pm.FindObject( objectId );
104 ············return m;
105 ········}
106
107 ········Mitarbeiter CreateMitarbeiterWithTravelAndAddress()
108 ········{
109 ············Mitarbeiter m = new Mitarbeiter();
110 ············m.Vorname = "Mirko";
111 ············m.Nachname = "Matytschak";
112 ············pm.MakePersistent( m );
113 ············m.Hinzufuegen( new Reise { Zweck = "Vortrag" } );
114 ············m.Adresse = new Adresse { Lkz = "D", Plz = "84149", Straße = "Ahornstr. 5", Ort="Eberspoint" };
115 ············pm.Save();
116 ············var objectId = m.NDOObjectId;
117 ············pm.UnloadCache();
118 ············m = (Mitarbeiter) this.pm.FindObject( objectId );
119 ············return m;
120 ········}
121
122 ········private Mitarbeiter CreateMitarbeiter()
123 ········{
124 ············Mitarbeiter m = new Mitarbeiter();
125 ············m.Vorname = "Mirko";
126 ············m.Nachname = "Matytschak";
127 ············m.Position = new System.Drawing.Point( 111, 222 );
128 ············return m;
129 ········}
130
131 ········[Test]
132 ········public void CanSerializeObject()
133 ········{
134 ············NdoJsonFormatter formatter = new NdoJsonFormatter(this.pm);
135 ············var m = CreatePersistentMitarbeiter();
136 ············Assert.That( m··!= null);
137 ············var ms = new MemoryStream();
138 ············formatter.Serialize( ms, m );
139 ············ms.Seek( 0L, SeekOrigin.Begin );
140 ············string json = null;
141 ············using (StreamReader sr = new StreamReader( ms ))
142 ············{
143 ················json = sr.ReadToEnd();
144 ············}
145
146 ············Assert.That( json··!= null);
147 ········}
148
149 ········[Test]
150 ········public void CanGetObjectContainer()
151 ········{
152 ············CreateObjectContainer();
153 ········}
154
155 ········private string CreateObjectContainer(bool serializeAddress = false)
156 ········{
157 ············NdoJsonFormatter formatter = new NdoJsonFormatter();
158 ············Mitarbeiter user = CreateMitarbeiterWithTravelAndAddress();
159 ············Assert.That( user··!= null);
160 ············var relations = serializeAddress ? new string[] { "dieReisen", "adresse" } : new string[]{"dieReisen"};
161 ············ObjectContainer container = new ObjectContainer(r=>relations.Contains( r.FieldName ));
162 ············container.AddObject( user );
163
164 ············var ms = new MemoryStream();
165 ············container.Serialize( ms, formatter );
166 ············ms.Seek( 0L, SeekOrigin.Begin );
167 ············string json = null;
168 ············using (StreamReader sr = new StreamReader( ms ))
169 ············{
170 ················json = sr.ReadToEnd();
171 ············}
172
173 ············Assert.That( json··!= null );
174 ············var jObj = JsonConvert.DeserializeObject<JObject>(json);
175 ············var rootObjects = (JArray)jObj["rootObjects"];
176 ············var additionalObjects = (JArray)jObj["additionalObjects"];
177 ············Assert.That( rootObjects··!= null);
178 ············Assert.That( additionalObjects··!= null);
179 ············Assert.That( 1 == rootObjects.Count() );
180 ············Assert.That( (serializeAddress ? 2 : 1) == additionalObjects.Count() );
181 ············var rootObject = rootObjects[0];
182 ············Assert.That( ( (string) rootObject["_oid"] ).StartsWith( "Mitarbeiter-F33D0A6D" ) );
183 ············return json;
184 ········}
185
186 ········[Test]
187 ········[TestCase(true)]
188 ········[TestCase( false )]
189 ········public void CanDeserializeObjectContainer(bool serializeAddress)
190 ········{
191 ············ObjectContainer oc = new ObjectContainer();
192 ············string json = CreateObjectContainer(serializeAddress);
193 ············this.pm = new PersistenceManager();
194 ············oc.Deserialize( json, new NdoJsonFormatter(this.pm) );
195 ············Assert.That( 1 == oc.RootObjects.Count );
196 ············Assert.That( oc.RootObjects[0] is Mitarbeiter );
197 ············Mitarbeiter m = (Mitarbeiter)oc.RootObjects[0];
198 ············Assert.That( "Mirko" == m.Vorname );
199 ············Assert.That( 1 == m.Reisen.Count );
200 ············if (serializeAddress)
201 ············{
202 ················Assert.That( m.Adresse··!= null);
203 ················Assert.That( "D" == m.Adresse.Lkz );
204 ············}
205 ············else
206 ············{
207 ················Assert.That( m.Adresse··== null );
208 ············}
209 ········}
210
211 ········[Test]
212 ········[TestCase(typeof(NdoJsonFormatter))]
213 ········public void ObjectContainerIsSerializable(Type formatterType)
214 ········{
215 ············INdoFormatter formatter = (INdoFormatter)Activator.CreateInstance(formatterType);
216
217 ············var m = CreateMitarbeiter();
218 ············pm.MakePersistent( m );
219 ············pm.Save();
220 ············var oc = pm.GetObjectContainer();
221 ············Assert.That( Object.ReferenceEquals( m, oc.RootObjects[0] ) );
222
223 ············oc.Formatter = formatter;
224 ············string serialized = oc.MarshalingString;
225
226 ············pm.UnloadCache();
227
228 ············var oc2 = pm.GetObjectContainer();
229 ············Assert.That( 0 == oc2.RootObjects.Count );
230
231 ············oc = new ObjectContainer();
232 ············oc.Deserialize( serialized, formatter );
233 ············pm.MergeObjectContainer( oc );
234
235 ············oc2 = pm.GetObjectContainer();
236 ············Assert.That( 1 == oc2.RootObjects.Count );
237
238 ············m = (Mitarbeiter) oc2.RootObjects[0];
239 ············Assert.That( "Mirko" == m.Vorname );
240 ············Assert.That( NDOObjectState.Persistent == m.NDOObjectState );
241 ········}
242
243
244 ········[Test]
245 ········[TestCase(typeof(NdoJsonFormatter))]
246 ········public void ChangeRelationWithExistingObject(Type formatterType)
247 ········{
248 ············// Create object and serialize it
249 ············INdoFormatter formatter = (INdoFormatter)Activator.CreateInstance(formatterType);
250
251 ············var r = new Reise { Zweck = "NDO" };
252 ············pm.MakePersistent(r);
253 ············var l = new Land("Germany");
254 ············pm.MakePersistent(l);
255 ············pm.Save();
256 ············var oc = pm.GetObjectContainer();
257
258 ············oc.Formatter = formatter;
259 ············string serialized = oc.MarshalingString;
260
261 ············pm.UnloadCache();
262
263 ············// Merge object in to an OfflinePersistenceManager and change it
264 ············OfflinePersistenceManager opm = new OfflinePersistenceManager(pm.NDOMapping.FileName);
265
266 ············oc = new ObjectContainer();
267 ············oc.Deserialize(serialized, formatter);
268
269 ············opm.MergeObjectContainer(oc);
270
271 ············var newOc = oc.RootObjects.Cast<IPersistenceCapable>();
272 ············var r2 = (Reise)newOc.FirstOrDefault(pc=>pc is Reise);
273 ············var l2 = (Land)newOc.FirstOrDefault(pc => pc is Land); ;
274 ············Assert.That( NDOObjectState.Persistent == r2.NDOObjectState);
275 ············Assert.That( NDOObjectState.Persistent == l2.NDOObjectState);
276 ············r2.LandHinzufügen(l2);
277 ············Assert.That( NDOObjectState.PersistentDirty == r2.NDOObjectState);
278
279 ············// Create a ChangeSetContainer and serialize it
280 ············var csc = opm.GetChangeSet();
281 ············csc.Formatter = formatter;
282 ············string serializedChanges = csc.MarshalingString;
283
284 ············// Merge the changes back to pm
285 ············csc = new ChangeSetContainer();
286 ············csc.Deserialize(serializedChanges, formatter);
287 ············r = (Reise)csc.ChangedObjects.Cast<IPersistenceCapable>().FirstOrDefault(pc => pc is Reise);
288 ············pm.MergeObjectContainer(csc);
289 ············r2 = (Reise)pm.FindObject(r.NDOObjectId);
290 ············Assert.That( NDOObjectState.PersistentDirty == r2.NDOObjectState);
291 ············Assert.That( 1 == r2.Länder.Count);
292
293 ············// Save and Reload
294 ············pm.Save();
295 ············pm.UnloadCache();
296 ············r = pm.Objects<Reise>().Single();
297 ············Assert.That( 1 == r2.Länder.Count);
298 ········}
299
300
301 ········[Test]
302 ········[TestCase(typeof(NdoJsonFormatter))]
303 ········public void ChangeRelationWithNewObject(Type formatterType)
304 ········{
305 ············// Create object and serialize it
306 ············INdoFormatter formatter = (INdoFormatter)Activator.CreateInstance(formatterType);
307
308 ············var m = CreateMitarbeiter();
309 ············pm.MakePersistent(m);
310 ············pm.Save();
311 ············var oc = pm.GetObjectContainer();
312
313 ············oc.Formatter = formatter;
314 ············string serialized = oc.MarshalingString;
315
316 ············pm.UnloadCache();
317
318 ············// Merge object in to an OfflinePersistenceManager and change it
319 ············OfflinePersistenceManager opm = new OfflinePersistenceManager(pm.NDOMapping.FileName);
320
321 ············oc = new ObjectContainer();
322 ············oc.Deserialize(serialized, formatter);
323
324 ············opm.MergeObjectContainer(oc);
325
326 ············var m2 = (Mitarbeiter)oc.RootObjects[0];
327 ············Assert.That( NDOObjectState.Persistent == m2.NDOObjectState);
328 ············m2.Hinzufuegen(new Reise() { Zweck = "NDO" });············
329 ············Assert.That( NDOObjectState.PersistentDirty == m2.NDOObjectState);
330
331 ············// Create a ChangeSetContainer and serialize it
332 ············var csc = opm.GetChangeSet();
333 ············csc.Formatter = formatter;
334 ············string serializedChanges = csc.MarshalingString;
335
336 ············// Merge the changes back to pm
337 ············csc = new ChangeSetContainer();
338 ············csc.Deserialize(serializedChanges, formatter);
339 ············m = (Mitarbeiter)csc.ChangedObjects[0];
340 ············pm.MergeObjectContainer(csc);
341 ············m2 = (Mitarbeiter)pm.FindObject(m.NDOObjectId);
342 ············Assert.That( NDOObjectState.PersistentDirty == m2.NDOObjectState);
343 ············Assert.That( 1 == m2.Reisen.Count);
344
345 ············// Save and Reload
346 ············pm.Save();
347 ············pm.UnloadCache();
348 ············m = pm.Objects<Mitarbeiter>().Single();
349 ············Assert.That( 1 == m2.Reisen.Count);
350 ········}
351
352 ········[Test]
353 ········[TestCase(typeof(NdoJsonFormatter))]
354 ········public void CompleteTurnaroundWithChangeSetContainer(Type formatterType)
355 ········{
356 ············// Create object and serialize it
357 ············INdoFormatter formatter = (INdoFormatter)Activator.CreateInstance(formatterType);
358
359 ············var m = CreateMitarbeiter();
360 ············pm.MakePersistent( m );
361 ············pm.Save();
362 ············var oc = pm.GetObjectContainer();
363
364 ············oc.Formatter = formatter;
365 ············string serialized = oc.MarshalingString;
366
367 ············pm.UnloadCache();
368
369 ············// Merge object in to an OfflinePersistenceManager and change it
370 ············OfflinePersistenceManager opm = new OfflinePersistenceManager( pm.NDOMapping.FileName );
371
372 ············oc = new ObjectContainer();
373 ············oc.Deserialize( serialized, formatter );
374
375 ············opm.MergeObjectContainer( oc );
376
377 ············var m2 = (Mitarbeiter)oc.RootObjects[0];
378 ············Assert.That( NDOObjectState.Persistent == m2.NDOObjectState );
379 ············m2.Vorname = "Hans";
380 ············Assert.That( NDOObjectState.PersistentDirty == m2.NDOObjectState );
381
382 ············// Create a ChangeSetContainer and serialize it
383 ············var csc = opm.GetChangeSet();
384 ············csc.Formatter = formatter;
385 ············string serializedChanges = csc.MarshalingString;
386
387 ············// Merge the changes back to pm
388 ············csc = new ChangeSetContainer();
389 ············csc.Deserialize( serializedChanges, formatter );
390 ············m = (Mitarbeiter) csc.ChangedObjects[0];
391 ············pm.MergeObjectContainer( csc );
392 ············m2 = (Mitarbeiter) pm.FindObject( m.NDOObjectId );
393 ············Assert.That( NDOObjectState.PersistentDirty == m2.NDOObjectState );
394 ············Assert.That( "Hans" == m.Vorname );
395
396 ············// Save and Reload
397 ············pm.Save();
398 ············pm.UnloadCache();
399 ············m = pm.Objects<Mitarbeiter>().Single();
400 ············Assert.That( "Hans" == m.Vorname );
401 ········}
402
403 ········[Test]
404 ········[TestCase(typeof(NdoJsonFormatter))]
405 ········public void CompleteTurnaroundWithAddedObject(Type formatterType)
406 ········{
407 ············// Create object and serialize it
408 ············INdoFormatter formatter = (INdoFormatter)Activator.CreateInstance(formatterType);
409
410 ············var m = CreateMitarbeiter();
411 ············pm.MakePersistent(m);
412 ············pm.Save();
413 ············var oc = pm.GetObjectContainer();
414
415 ············oc.Formatter = formatter;
416 ············string serialized = oc.MarshalingString;
417
418 ············pm.UnloadCache();
419
420 ············// Merge object into an OfflinePersistenceManager and change it
421 ············OfflinePersistenceManager opm = new OfflinePersistenceManager(pm.NDOMapping.FileName);
422
423 ············oc = new ObjectContainer();
424 ············oc.Deserialize(serialized, formatter);
425
426 ············opm.MergeObjectContainer(oc);
427
428 ············var m2 = new Mitarbeiter() { Vorname = "Hans", Nachname = "Müller" };
429 ············opm.MakePersistent(m2);
430
431 ············// Create a ChangeSetContainer and serialize it
432 ············var csc = opm.GetChangeSet();
433 ············csc.Formatter = formatter;
434 ············string serializedChanges = csc.MarshalingString;
435
436 ············// Merge the changes back to pm
437 ············csc = new ChangeSetContainer();
438 ············csc.Deserialize(serializedChanges, formatter);
439
440 ············Assert.That(csc.AddedObjects.Count == 1);
441
442 ············pm = new PersistenceManager();··// we need a new pm here which get's us id's beginning from -1
443 ············pm.MergeObjectContainer(csc);
444 ············// Now we should have a created object in the cache
445 ············Assert.That( true == pm.HasChanges);
446 ············m = (Mitarbeiter)pm.FindObject(typeof(Mitarbeiter), -1);
447 ············Assert.That(m.NDOObjectState == NDOObjectState.Created);
448
449 ············// Save and Reload
450 ············pm.Save();
451 ············Assert.That(m.NDOObjectState == NDOObjectState.Persistent);
452 ············pm.UnloadCache();
453 ············var l = pm.Objects<Mitarbeiter>().ResultTable;
454 ············Assert.That( 2 == l.Count);
455 ············Assert.That(l.Any(m1 => m1.Vorname == "Mirko" && m1.Nachname == "Matytschak"));
456 ············Assert.That(l.Any(m1 => m1.Vorname == "Hans" && m1.Nachname == "Müller"));
457 ········}
458
459 ········[Test]
460 ········public void CanSetObjectsToHollow()
461 ········{
462 ············var formatter = new NdoJsonFormatter();
463 ············var serializationIterator = new NDO.SerializationIterator( r => r.ReferencedType == typeof( Reise ), pc => pc.NDOObjectState = NDOObjectState.Hollow );
464
465 ············var m = CreateMitarbeiter();
466 ············pm.MakePersistent( m );
467 ············Reise reise;
468 ············m.Hinzufuegen( reise = new Reise() { Zweck = "NDO" } );
469 ············pm.Save();
470
471 ············var oc = pm.GetObjectContainer();
472 ············oc.SerialisationIterator = serializationIterator;
473
474 ············bool found = false;
475 ············foreach (object o in oc.RootObjects)
476 ············{
477 ················if (Object.ReferenceEquals( m, o ))
478 ····················found = true;
479 ············}
480 ············Assert.That( found );
481
482 ············Assert.That( NDOObjectState.Persistent == m.NDOObjectState );
483
484 ············oc.Formatter = formatter;
485 ············string serialized = oc.MarshalingString;
486
487 ············Assert.That( 2 == oc.RootObjects.Count );
488 ············Assert.That( NDOObjectState.Hollow == m.NDOObjectState );
489 ············Assert.That( NDOObjectState.Hollow == reise.NDOObjectState );
490 ········}
491
492 ········[Test]
493 ········[TestCase(typeof(NdoJsonFormatter))]
494 ········public void ObjectContainerSerializesRelations(Type formatterType)
495 ········{
496 ············INdoFormatter formatter = (INdoFormatter)Activator.CreateInstance(formatterType);
497 ············var serializationIterator = new NDO.SerializationIterator( r => r.ReferencedType == typeof( Reise ) );
498
499 ············var m = CreateMitarbeiter();
500 ············pm.MakePersistent( m );
501 ············m.Hinzufuegen( new Reise() { Zweck = "NDO" } );
502 ············pm.Save();
503
504 ············var oc = pm.GetObjectContainer();
505
506 ············bool found = false;
507 ············foreach (object o in oc.RootObjects)
508 ············{
509 ················if (Object.ReferenceEquals( m, o ))
510 ····················found = true;
511 ············}
512 ············Assert.That( found );
513
514 ············oc.SerialisationIterator = serializationIterator;
515 ············oc.Formatter = formatter;
516 ············string serialized = oc.MarshalingString;
517
518 ············Assert.That( 2 == oc.RootObjects.Count );
519
520 ············pm.UnloadCache();
521
522 ············var oc2 = pm.GetObjectContainer();
523 ············Assert.That( 0 == oc2.RootObjects.Count );
524
525 ············oc = new ObjectContainer();
526 ············oc.Deserialize( serialized, formatter );
527 ············pm.MergeObjectContainer( oc );
528
529 ············oc2 = pm.GetObjectContainer();
530 ············Assert.That( 2 == oc2.RootObjects.Count );
531
532 ············Reise r2 = null;
533 ············Mitarbeiter m2 = null;
534
535 ············foreach (object o in oc2.RootObjects)
536 ············{
537 ················if (o is Reise)
538 ····················r2 = (Reise) o;
539 ················if (o is Mitarbeiter)
540 ····················m2 = (Mitarbeiter) o;
541 ············}
542
543 ············Assert.That( r2··!= null);
544 ············Assert.That( m2··!= null);
545
546 ············Assert.That( "Mirko" == m2.Vorname );
547 ············Assert.That( NDOObjectState.Persistent == m2.NDOObjectState );
548
549 ············Assert.That( "NDO" == r2.Zweck );
550 ············Assert.That( NDOObjectState.Persistent == r2.NDOObjectState );
551 ········}
552 ········[Test]
553 ········public void TestJsonNull()
554 ········{
555 ············var formatter = new NdoJsonFormatter(this.pm);
556 ············MemoryStream ms = new MemoryStream();
557 ············StreamWriter sw = new StreamWriter(ms);
558 ············sw.Write("null");
559 ············ms.Position = 0;
560
561 ············object obj = formatter.Deserialize(ms);
562 ············Assert.That( obj == null );
563 ········}
564
565 ····}
566 }
567