Datei: IntegrationTests/IntegrationTests/AuditTests.cs

Last Commit (9d1552b)
1 using System;
2 using System.Collections.Generic;
3 using System.Linq;
4 using System.Text;
5 using System.Threading.Tasks;
6 using NUnit.Framework;
7 using PureBusinessClasses;
8 using NDO;
9 using NDO.ShortId;
10 using Reisekosten.Personal;
11 using Reisekosten;
12 using Newtonsoft.Json;
13
14 namespace NdoUnitTests
15 {
16 ····[TestFixture]
17 public class AuditTests
18 ····{
19 ········Mitarbeiter m;
20 ········Reise r;
21
22 ········[SetUp]
23 ········public void Setup()
24 ········{
25 ············var pm = PmFactory.NewPersistenceManager();
26 ············m = CreateMitarbeiter( "Mirko", "Matytschak" );
27 ············pm.MakePersistent( m );
28 ············m.ErzeugeReise().Zweck = "ADC";
29 ············pm.Save();
30 ············pm.UnloadCache();
31 ········}
32
33 ········[TearDown]
34 ········public void TearDown()
35 ········{
36 ············var pm = PmFactory.NewPersistenceManager();
37 ············pm.TransactionMode = TransactionMode.None;
38 ············var mitarbeiterListe = pm.GetClassExtent( typeof( Mitarbeiter ), true );
39 ············pm.Delete( mitarbeiterListe );
40 ············pm.Save();
41 ············pm.UnloadCache();
42 ············using (var handler = pm.GetSqlPassThroughHandler())
43 ············{
44 ················handler.Execute( $"DELETE FROM {pm.NDOMapping.FindClass( typeof( Reise ) ).TableName}" );
45 ················handler.Execute( $"DELETE FROM {pm.NDOMapping.FindClass( typeof( Adresse ) ).TableName}" );
46 ············}
47 ········}
48
49 ········private Mitarbeiter CreateMitarbeiter( string vorname, string nachname )
50 ········{
51 ············Mitarbeiter m = new Mitarbeiter();
52 ············m.Vorname = vorname;
53 ············m.Nachname = nachname;
54 ············return m;
55 ········}
56
57 ········[Test]
58 ········public void ChangeSetDetectsSimpleChange()
59 ········{
60 ············var pm = PmFactory.NewPersistenceManager();
61 ············m = pm.Objects<Mitarbeiter>().Single();
62 ············m.Vorname = "Hans";
63 ············var changeObject = pm.GetChangeSet( m );
64 ············Assert.That(1 ==··changeObject.original.Count );
65 ············Assert.That(1 ==··changeObject.current.Count );
66 ············Assert.That("Mirko", Is.EqualTo( changeObject.original["vorname"] ) );
67 ············Assert.That("Hans", Is.EqualTo( changeObject.current["vorname"] ) );
68 ········}
69
70 ········[Test]
71 ········public void ChangeSetDetectsObjectAddition1_to_n()
72 ········{
73 ············var pm = PmFactory.NewPersistenceManager();
74 ············m = pm.Objects<Mitarbeiter>().Single();
75 ············var r = m.ErzeugeReise();
76 ············r.Zweck = "Test";
77 ············var changeObject = pm.GetChangeSet( m );
78 ············var original = changeObject.original;
79 ············var current = changeObject.current;
80 ············Assert.That(1 ==··original.Count );
81 ············Assert.That(1 ==··current.Count );
82 ············Assert.That( original.ContainsKey("dieReisen") );
83 ············Assert.That( current.ContainsKey( "dieReisen" ) );
84 ············Assert.That(1 ==··((List<ObjectId>)original["dieReisen"]).Count );
85 ············Assert.That(2 ==··((List<ObjectId>)current["dieReisen"]).Count );
86 ············Assert.That(r.NDOObjectId ==··((List<ObjectId>)current["dieReisen"])[1] );
87 ············// At this point it doesn't make any sense to serialize the changeObject,
88 ············// since the id of r is not yet determined.
89 ············Assert.That( (int)r.NDOObjectId.Id[0] < 0 );
90 ············pm.Save();
91 ············// Now the id of r is determined. Let's assert, that the list in current reflects the change.
92 ············Assert.That( (int)r.NDOObjectId.Id[0] > 0 );
93 ············Assert.That(r.NDOObjectId ==··((List<ObjectId>)current["dieReisen"])[1] );
94
95 ············changeObject = changeObject.SerializableClone();
96 ············original = changeObject.original;
97 ············current = changeObject.current;
98 ············Assert.That(1 ==··original.Count );
99 ············Assert.That(1 ==··current.Count );
100 ············Assert.That( original.ContainsKey( "dieReisen" ) );
101 ············Assert.That( current.ContainsKey( "dieReisen" ) );
102 ············Assert.That(1 ==··( (List<string>) original["dieReisen"] ).Count );
103 ············Assert.That(2 ==··( (List<string>) current["dieReisen"] ).Count );
104 ············Assert.That(r.NDOObjectId.ToShortId() ==··( (List<string>) current["dieReisen"] )[1] );
105 ············string json = JsonConvert.SerializeObject(changeObject);
106 ········}
107
108 ········[Test]
109 ········public void ChangeSetDetectsObjectDeletion1_to_n()
110 ········{
111 ············var pm = PmFactory.NewPersistenceManager();
112 ············m = pm.Objects<Mitarbeiter>().Single();
113 ············m.Löschen( m.Reisen[0] );
114 ············var changeObject = pm.GetChangeSet( m );
115 ············var original = changeObject.original;
116 ············var current = changeObject.current;
117 ············Assert.That(1 ==··original.Count );
118 ············Assert.That(1 ==··current.Count );
119 ············Assert.That( original.ContainsKey( "dieReisen" ) );
120 ············Assert.That( current.ContainsKey( "dieReisen" ) );
121 ············Assert.That(1 ==··((List<ObjectId>)original["dieReisen"]).Count );
122 ············Assert.That(0 ==··((List<ObjectId>)current["dieReisen"]).Count );
123 ········}
124
125 ········[Test]
126 ········public void ChangeSetDetectsObjectAddition1_to_1()
127 ········{
128 ············var pm = PmFactory.NewPersistenceManager();
129 ············m = pm.Objects<Mitarbeiter>().Single();
130 ············Adresse a = new Adresse() { Ort = "München", Straße = "Teststr", Plz = "80133" };
131 ············m.Adresse = a;
132 ············var changeObject = pm.GetChangeSet( m );
133 ············var original = changeObject.original;
134 ············var current = changeObject.current;
135 ············Assert.That(1 ==··original.Count );
136 ············Assert.That(1 ==··current.Count );
137 ············Assert.That( original.ContainsKey( "adresse" ) );
138 ············Assert.That( current.ContainsKey( "adresse" ) );
139 ············Assert.That(a.NDOObjectId ==··((List<ObjectId>) current["adresse"])[0] );
140 ············// At this point it doesn't make any sense to serialize the changeObject,
141 ············// since the id of a is not yet determined.
142 ············Assert.That( (int)a.NDOObjectId.Id[0] < 0 );
143 ············pm.Save();
144 ············var newChangeObject = changeObject.SerializableClone();
145 ············// Now the id of r is determined. Let's assert, that the list in current reflects the change.
146 ············Assert.That( (int)a.NDOObjectId.Id[0] > 0 );
147 ············Assert.That(a.NDOObjectId.ToShortId() ==··((List<string>)newChangeObject.current["adresse"])[0] );
148 ········}
149
150 ········[Test]
151 ········public void ChangeSetDetectsObjectDeletion1_to_1()
152 ········{
153 ············var pm = PmFactory.NewPersistenceManager();
154 ············m = pm.Objects<Mitarbeiter>().Single();
155 ············Adresse a = new Adresse() { Ort = "München", Straße = "Teststr", Plz = "80133" };
156 ············m.Adresse = a;
157 ············pm.Save();
158 ············pm.UnloadCache();
159 ············m = pm.Objects<Mitarbeiter>().Single();
160 ············m.Adresse = null;
161 ············var changeObject = pm.GetChangeSet( m );
162 ············var original = changeObject.original;
163 ············var current = changeObject.current;
164 ············Assert.That(1 ==··original.Count );
165 ············Assert.That(1 ==··current.Count );
166 ············Assert.That( original.ContainsKey( "adresse" ) );
167 ············Assert.That( current.ContainsKey( "adresse" ) );
168 ············Assert.That(1 ==··((List<ObjectId>)original["adresse"]).Count );
169 ············Assert.That(0 ==··((List<ObjectId>)current["adresse"]).Count );
170 ········}
171 ····}
172 }
173
New Commit (60cb179)
1 using System;
2 using System.Collections.Generic;
3 using System.Linq;
4 using System.Text;
5 using System.Threading.Tasks;
6 using NUnit.Framework;
7 using PureBusinessClasses;
8 using NDO;
9 using NDO.ShortId;
10 using Reisekosten.Personal;
11 using Reisekosten;
12 using Newtonsoft.Json;
13
14 namespace NdoUnitTests
15 {
16 ····[TestFixture]
17 public class AuditTests : NDOTest
18 ····{
19 ········Mitarbeiter m;
20 ········Reise r;
21
22 ········[SetUp]
23 ········public void Setup()
24 ········{
25 ············var pm = PmFactory.NewPersistenceManager();
26 ············m = CreateMitarbeiter( "Mirko", "Matytschak" );
27 ············pm.MakePersistent( m );
28 ············m.ErzeugeReise().Zweck = "ADC";
29 ············pm.Save();
30 ············pm.UnloadCache();
31 ········}
32
33 ········[TearDown]
34 ········public void TearDown()
35 ········{
36 ············var pm = PmFactory.NewPersistenceManager();
37 ············pm.TransactionMode = TransactionMode.None;
38 ············var mitarbeiterListe = pm.GetClassExtent( typeof( Mitarbeiter ), true );
39 ············pm.Delete( mitarbeiterListe );
40 ············pm.Save();
41 ············pm.UnloadCache();
42 ············using (var handler = pm.GetSqlPassThroughHandler())
43 ············{
44 ················handler.Execute( $"DELETE FROM {pm.NDOMapping.FindClass( typeof( Reise ) ).TableName}" );
45 ················handler.Execute( $"DELETE FROM {pm.NDOMapping.FindClass( typeof( Adresse ) ).TableName}" );
46 ············}
47 ········}
48
49 ········private Mitarbeiter CreateMitarbeiter( string vorname, string nachname )
50 ········{
51 ············Mitarbeiter m = new Mitarbeiter();
52 ············m.Vorname = vorname;
53 ············m.Nachname = nachname;
54 ············return m;
55 ········}
56
57 ········[Test]
58 ········public void ChangeSetDetectsSimpleChange()
59 ········{
60 ············var pm = PmFactory.NewPersistenceManager();
61 ············m = pm.Objects<Mitarbeiter>().Single();
62 ············m.Vorname = "Hans";
63 ············var changeObject = pm.GetChangeSet( m );
64 ············Assert.That(1 ==··changeObject.original.Count );
65 ············Assert.That(1 ==··changeObject.current.Count );
66 ············Assert.That("Mirko", Is.EqualTo( changeObject.original["vorname"] ) );
67 ············Assert.That("Hans", Is.EqualTo( changeObject.current["vorname"] ) );
68 ········}
69
70 ········[Test]
71 ········public void ChangeSetDetectsObjectAddition1_to_n()
72 ········{
73 ············var pm = PmFactory.NewPersistenceManager();
74 ············m = pm.Objects<Mitarbeiter>().Single();
75 ············var r = m.ErzeugeReise();
76 ············r.Zweck = "Test";
77 ············var changeObject = pm.GetChangeSet( m );
78 ············var original = changeObject.original;
79 ············var current = changeObject.current;
80 ············Assert.That(1 ==··original.Count );
81 ············Assert.That(1 ==··current.Count );
82 ············Assert.That( original.ContainsKey("dieReisen") );
83 ············Assert.That( current.ContainsKey( "dieReisen" ) );
84 ············Assert.That(1 ==··((List<ObjectId>)original["dieReisen"]).Count );
85 ············Assert.That(2 ==··((List<ObjectId>)current["dieReisen"]).Count );
86 ············Assert.That(r.NDOObjectId ==··((List<ObjectId>)current["dieReisen"])[1] );
87 ············// At this point it doesn't make any sense to serialize the changeObject,
88 ············// since the id of r is not yet determined.
89 ············Assert.That( (int)r.NDOObjectId.Id[0] < 0 );
90 ············pm.Save();
91 ············// Now the id of r is determined. Let's assert, that the list in current reflects the change.
92 ············Assert.That( (int)r.NDOObjectId.Id[0] > 0 );
93 ············Assert.That(r.NDOObjectId ==··((List<ObjectId>)current["dieReisen"])[1] );
94
95 ············changeObject = changeObject.SerializableClone();
96 ············original = changeObject.original;
97 ············current = changeObject.current;
98 ············Assert.That(1 ==··original.Count );
99 ············Assert.That(1 ==··current.Count );
100 ············Assert.That( original.ContainsKey( "dieReisen" ) );
101 ············Assert.That( current.ContainsKey( "dieReisen" ) );
102 ············Assert.That(1 ==··( (List<string>) original["dieReisen"] ).Count );
103 ············Assert.That(2 ==··( (List<string>) current["dieReisen"] ).Count );
104 ············Assert.That(r.NDOObjectId.ToShortId() ==··( (List<string>) current["dieReisen"] )[1] );
105 ············string json = JsonConvert.SerializeObject(changeObject);
106 ········}
107
108 ········[Test]
109 ········public void ChangeSetDetectsObjectDeletion1_to_n()
110 ········{
111 ············var pm = PmFactory.NewPersistenceManager();
112 ············m = pm.Objects<Mitarbeiter>().Single();
113 ············m.Löschen( m.Reisen[0] );
114 ············var changeObject = pm.GetChangeSet( m );
115 ············var original = changeObject.original;
116 ············var current = changeObject.current;
117 ············Assert.That(1 ==··original.Count );
118 ············Assert.That(1 ==··current.Count );
119 ············Assert.That( original.ContainsKey( "dieReisen" ) );
120 ············Assert.That( current.ContainsKey( "dieReisen" ) );
121 ············Assert.That(1 ==··((List<ObjectId>)original["dieReisen"]).Count );
122 ············Assert.That(0 ==··((List<ObjectId>)current["dieReisen"]).Count );
123 ········}
124
125 ········[Test]
126 ········public void ChangeSetDetectsObjectAddition1_to_1()
127 ········{
128 ············var pm = PmFactory.NewPersistenceManager();
129 ············m = pm.Objects<Mitarbeiter>().Single();
130 ············Adresse a = new Adresse() { Ort = "München", Straße = "Teststr", Plz = "80133" };
131 ············m.Adresse = a;
132 ············var changeObject = pm.GetChangeSet( m );
133 ············var original = changeObject.original;
134 ············var current = changeObject.current;
135 ············Assert.That(1 ==··original.Count );
136 ············Assert.That(1 ==··current.Count );
137 ············Assert.That( original.ContainsKey( "adresse" ) );
138 ············Assert.That( current.ContainsKey( "adresse" ) );
139 ············Assert.That(a.NDOObjectId ==··((List<ObjectId>) current["adresse"])[0] );
140 ············// At this point it doesn't make any sense to serialize the changeObject,
141 ············// since the id of a is not yet determined.
142 ············Assert.That( (int)a.NDOObjectId.Id[0] < 0 );
143 ············pm.Save();
144 ············var newChangeObject = changeObject.SerializableClone();
145 ············// Now the id of r is determined. Let's assert, that the list in current reflects the change.
146 ············Assert.That( (int)a.NDOObjectId.Id[0] > 0 );
147 ············Assert.That(a.NDOObjectId.ToShortId() ==··((List<string>)newChangeObject.current["adresse"])[0] );
148 ········}
149
150 ········[Test]
151 ········public void ChangeSetDetectsObjectDeletion1_to_1()
152 ········{
153 ············var pm = PmFactory.NewPersistenceManager();
154 ············m = pm.Objects<Mitarbeiter>().Single();
155 ············Adresse a = new Adresse() { Ort = "München", Straße = "Teststr", Plz = "80133" };
156 ············m.Adresse = a;
157 ············pm.Save();
158 ············pm.UnloadCache();
159 ············m = pm.Objects<Mitarbeiter>().Single();
160 ············m.Adresse = null;
161 ············var changeObject = pm.GetChangeSet( m );
162 ············var original = changeObject.original;
163 ············var current = changeObject.current;
164 ············Assert.That(1 ==··original.Count );
165 ············Assert.That(1 ==··current.Count );
166 ············Assert.That( original.ContainsKey( "adresse" ) );
167 ············Assert.That( current.ContainsKey( "adresse" ) );
168 ············Assert.That(1 ==··((List<ObjectId>)original["adresse"]).Count );
169 ············Assert.That(0 ==··((List<ObjectId>)current["adresse"]).Count );
170 ········}
171 ····}
172 }
173