Datei: IntegrationTests/IntegrationTests/TransactionTests.cs

Last Commit (60aa080)
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 NUnit.Framework;
24 using NDO;
25 using Reisekosten.Personal;
26 using NDO.Query;
27 using Reisekosten;
28 using Formfakten.TestLogger;
29
30 namespace NdoUnitTests
31 {
32 ····[TestFixture]
33 public class TransactionScopeTests : NDOTest
34 ····{
 
35 ········public void Setup()
36 ········{
37 ············Logger.ClearTestLogs();
38 ········}
39
 
40 ········public void TearDown()
41 ········{
42 ············Logger.ClearTestLogs();
43 ············var pm = PmFactory.NewPersistenceManager();
44 ············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm );
45 ············pm.Delete( q.Execute() );
46 ········}
47
48
49 ········/*
50 ········forceCommit should be:
51 ········
52 ····················Query····Save····Save(true)
53 ········Optimistic····1········1········0
54 ········Pessimistic····0········1········0
55 ············
56 ········Deferred Mode············
57 ····················Query····Save····Save(true)
58 ········Optimistic····0········1········0
59 ········Pessimistic····0········1········0
60
61 ········ */
62
63 ········[Test]
64 ········public void TestIfQueryWithoutTransactionDoesNotStartAndNotCommit()
65 ········{
66 ············using (var pm = PmFactory.NewPersistenceManager())
67 ············{
68 ················pm.TransactionMode = TransactionMode.None;
69 ················new NDOQuery<Mitarbeiter>( pm ).Execute();
70 ················var startCount = Logger.FindLogsWith("Starting transaction").Count;
71 ················var commitCount = Logger.FindLogsWith("Committing transaction").Count;
72 ················Assert.That( startCount == 0, "Transaction shouldn't be started" );
73 ················Assert.That( commitCount == 0, "Transaction shouldn't be committed" );
74 ············}
75 ········}
76
77
78 ········[Test]
79 ········public void TestIfOptimisticQueryIsImmediatelyCommitted()
80 ········{
81 ············using (var pm = PmFactory.NewPersistenceManager())
82 ············{
83 ················pm.TransactionMode = TransactionMode.Optimistic;
84 ················new NDOQuery<Mitarbeiter>( pm ).Execute();
85 ················var commitCount = Logger.FindLogsWith("Committing transaction").Count;
86 ················Assert.That( commitCount > 0, "Transaction should be committed" );
87 ············}
88 ········}
89
90 ········[Test]
91 ········public void TestIfPessimisticQueryIsNotCommitted()
92 ········{
93 ············using (var pm = PmFactory.NewPersistenceManager())
94 ············{
95 ················pm.TransactionMode = TransactionMode.Pessimistic;
96 ················new NDOQuery<Mitarbeiter>( pm ).Execute();
97 ················var startCount = Logger.FindLogsWith("Starting transaction").Count;
98 ················var commitCount = Logger.FindLogsWith("Committing transaction").Count;
99 ················Assert.That( startCount > 0, "Transaction should be started" );
100 ················Assert.That( commitCount == 0, "Transaction shouldn't be committed" );
101 ············}
102 ········}
103
104 ········[Test]
105 ········public void TestIfOptimisticSaveIsCommitted()
106 ········{
107 ············using (var pm = PmFactory.NewPersistenceManager())
108 ············{
109 ················pm.TransactionMode = TransactionMode.Optimistic;
110 ················Mitarbeiter m = new Mitarbeiter();
111 ················pm.MakePersistent( m );
112 ················pm.Save();
113
114 ················var startCount = Logger.FindLogsWith("Starting transaction").Count;
115 ················var commitCount = Logger.FindLogsWith("Committing transaction").Count;
116 ················Assert.That( startCount > 0, "Transaction should be started" );
117 ················Assert.That( commitCount > 0, "Transaction should be committed" );
118 ············}
119 ········}
120
121 ········[Test]
122 ········public void TestIfPessimisticSaveIsCommitted()
123 ········{
124 ············using (var pm = PmFactory.NewPersistenceManager())
125 ············{
126 ················pm.TransactionMode = TransactionMode.Pessimistic;
127 ················Mitarbeiter m = new Mitarbeiter();
128 ················pm.MakePersistent( m );
129 ················pm.Save();
130
131 ················var startCount = Logger.FindLogsWith("Starting transaction").Count;
132 ················var commitCount = Logger.FindLogsWith("Committing transaction").Count;
133 ················Assert.That( startCount > 0, "Transaction should be started" );
134 ················Assert.That( commitCount > 0, "Transaction should be committed" );
135 ············}
136 ········}
137
138 ········[Test]
139 ········public void OptimisticQueryAndSaveShouldHaveTwoTransactions()
140 ········{
141 ············using (var pm = PmFactory.NewPersistenceManager())
142 ············{
143 ················pm.TransactionMode = TransactionMode.Optimistic;
144 ················new NDOQuery<Mitarbeiter>( pm ).Execute();
145 ················Mitarbeiter m = new Mitarbeiter();
146 ················pm.MakePersistent( m );
147 ················pm.Save();
148
149 ················var startCount = Logger.FindLogsWith("Starting transaction").Count;
150 ················var commitCount = Logger.FindLogsWith("Committing transaction").Count;
151 ················Assert.That( startCount == 2, "Two Transactions should be started" );
152 ················Assert.That( commitCount == 2, "Two Transactions should be committed" );
153 ············}
154 ········}
155
156 ········[Test]
157 ········public void PessimisticQueryAndSaveShouldHaveOneTransaction()
158 ········{
159 ············using (var pm = PmFactory.NewPersistenceManager())
160 ············{
161 ················pm.TransactionMode = TransactionMode.Pessimistic;
162 ················new NDOQuery<Mitarbeiter>( pm ).Execute();
163 ················Mitarbeiter m = new Mitarbeiter();
164 ················pm.MakePersistent( m );
165 ················pm.Save();
166
167 ················var startCount = Logger.FindLogsWith("Starting transaction").Count;
168 ················var commitCount = Logger.FindLogsWith("Committing transaction").Count;
169 ················Assert.That( startCount == 1, "One Transaction should be started" );
170 ················Assert.That( commitCount == 1, "One Transaction should be committed" );
171 ············}
172 ········}
173
174 ········[Test]
175 ········public void OptimisticDeferredSaveShouldNotCommit()
176 ········{
177 ············using (var pm = PmFactory.NewPersistenceManager())
178 ············{
179 ················pm.TransactionMode = TransactionMode.Optimistic;
180 ················Mitarbeiter m = new Mitarbeiter();
181 ················pm.MakePersistent( m );
182 ················pm.Save( true );
183
184 ················var startCount = Logger.FindLogsWith("Starting transaction").Count;
185 ················var commitCount = Logger.FindLogsWith("Committing transaction").Count;
186 ················Assert.That( startCount > 0, "Transaction should be started" );
187 ················Assert.That( commitCount == 0, "Transaction shouldn't be committed" );
188 ············}
189 ········}
190
191 ········[Test]
192 ········public void PessimisticDeferredSaveShouldNotCommit()
193 ········{
194 ············using (var pm = PmFactory.NewPersistenceManager())
195 ············{
196 ················pm.TransactionMode = TransactionMode.Pessimistic;
197 ················Mitarbeiter m = new Mitarbeiter();
198 ················pm.MakePersistent( m );
199 ················pm.Save( true );
200 ················var startCount = Logger.FindLogsWith("Starting transaction").Count;
201 ················var commitCount = Logger.FindLogsWith("Committing transaction").Count;
202 ················Assert.That( startCount > 0, "Transaction should be started" );
203 ················Assert.That( commitCount == 0, "Transaction shouldn't be committed" );
204 ············}
205 ········}
206
207 ········[Test]
208 ········public void OptimisticDeferredSaveAndQueryShouldNotCommit()
209 ········{
210 ············using (var pm = PmFactory.NewPersistenceManager())
211 ············{
212 ················pm.TransactionMode = TransactionMode.Optimistic;
213 ················Mitarbeiter m = new Mitarbeiter();
214 ················pm.MakePersistent( m );
215 ················pm.Save( true );
216 ················new NDOQuery<Mitarbeiter>( pm ).Execute();
217
218 ················var startCount = Logger.FindLogsWith("Starting transaction").Count;
219 ················var commitCount = Logger.FindLogsWith("Committing transaction").Count;
220 ················Assert.That( startCount > 0, "Transaction should be started" );
221 ················Assert.That( commitCount == 0, "Transaction shouldn't be committed" );
222 ············}
223 ········}
224
225 ········[Test]
226 ········public void PessimisticDeferredSaveAndQueryShouldNotCommit()
227 ········{
228 ············using (var pm = PmFactory.NewPersistenceManager())
229 ············{
230 ················pm.TransactionMode = TransactionMode.Pessimistic;
231 ················Mitarbeiter m = new Mitarbeiter();
232 ················pm.MakePersistent( m );
233 ················pm.Save( true );
234 ················new NDOQuery<Mitarbeiter>( pm ).Execute();
235
236 ················var startCount = Logger.FindLogsWith("Starting transaction").Count;
237 ················var commitCount = Logger.FindLogsWith("Committing transaction").Count;
238 ················Assert.That( startCount > 0, "Transaction should be started" );
239 ················Assert.That( commitCount == 0, "Transaction shouldn't be committed" );
240 ············}
241 ········}
242
243 ········[Test]
244 ········public void OptimisticSaveAfterDeferredSaveShouldCommit()
245 ········{
246 ············using (var pm = PmFactory.NewPersistenceManager())
247 ············{
248 ················pm.TransactionMode = TransactionMode.Optimistic;
249 ················Mitarbeiter m = new Mitarbeiter();
250 ················pm.MakePersistent( m );
251 ················pm.Save( true );
252 ················m.Nachname = "Test";
253 ················pm.Save();
254
255 ················var startCount = Logger.FindLogsWith("Starting transaction").Count;
256 ················var commitCount = Logger.FindLogsWith("Committing transaction").Count;
257 ················Assert.That( startCount == 1, "Transaction should be started" );
258 ················Assert.That( commitCount == 1, "Transaction should be committed" );
259 ············}
260 ········}
261
262 ········[Test]
263 ········public void PessimisticSaveAfterDeferredSaveShouldCommit()
264 ········{
265 ············using (var pm = PmFactory.NewPersistenceManager())
266 ············{
267 ················pm.TransactionMode = TransactionMode.Pessimistic;
268 ················Mitarbeiter m = new Mitarbeiter();
269 ················pm.MakePersistent( m );
270 ················pm.Save( true );
271 ················m.Nachname = "Test";
272 ················pm.Save();
273
274 ················var startCount = Logger.FindLogsWith("Starting transaction").Count;
275 ················var commitCount = Logger.FindLogsWith("Committing transaction").Count;
276 ················Assert.That( startCount == 1, "Transaction should be started" );
277 ················Assert.That( commitCount == 1, "Transaction should be committed" );
278 ············}
279 ········}
280
281
282 ········[Test]
283 ········public void DirectSqlPassThroughWithoutTransactionShouldNotCommit()
284 ········{
285 ············using (var pm = PmFactory.NewPersistenceManager())
286 ············{
287 ················pm.TransactionMode = TransactionMode.None;
288 ················using (ISqlPassThroughHandler sqlHandler = pm.GetSqlPassThroughHandler())
289 ················{
290 ····················var reader = sqlHandler.Execute( "DELETE FROM Mitarbeiter" );
291 ····················Assert.That( reader == null, "Reader should be null" );
292 ················}
293
294 ················var startCount = Logger.FindLogsWith("Starting transaction").Count;
295 ················var commitCount = Logger.FindLogsWith("Committing transaction").Count;
296 ················Assert.That( startCount == 0, "Transaction shouldn't be started" );
297 ················Assert.That( commitCount == 0, "Transaction shouldn't be committed" );
298 ············}
299 ········}
300
301 ········int FlughafenCount( PersistenceManager pm )
302 ········{
303 ············NDOQuery<Flughafen> q = new NDOQuery<Flughafen>( pm );
304 ············return (int) (decimal) q.ExecuteAggregate( "oid", AggregateType.Count );
305 ········}
306
307 ········int LänderCount( PersistenceManager pm )
308 ········{
309 ············NDOQuery<Land> q = new NDOQuery<Land>( pm );
310 ············return (int) (decimal) q.ExecuteAggregate( "oid", AggregateType.Count );
311 ········}
312
313 ········[Test]
314 ········public void AbortedDeferredMultiStepTransactionDoesNotCommit()
315 ········{
316 ············using (var pm = PmFactory.NewPersistenceManager())
317 ············{
318 ················var landCount = LänderCount( pm );
319 ················var fhCount = FlughafenCount( pm );
320
321 ················pm.TransactionMode = TransactionMode.Optimistic;
322
323 ················Land land = new Land();
324 ················land.Name = "Germany";
325 ················pm.MakePersistent( land );
326 ················pm.Save( true );
327
328 ················var flughafen = new Flughafen();
329 ················flughafen.Kürzel = "MUC";
330 ················pm.MakePersistent( flughafen );
331 ················land.AddFlughafen( flughafen );
332 ················pm.Save( true );
333
334 ················pm.Abort();
335
336 ················Assert.That( landCount == LänderCount( pm ) );
337 ················Assert.That( fhCount == FlughafenCount( pm ) );
338 ············}
339 ········}
340
341 ········[Test]
342 ········public void DirectSqlPassThroughWithTransactionShouldCommit()
343 ········{
344 ············using (var pm = PmFactory.NewPersistenceManager())
345 ············{
346 ················using (ISqlPassThroughHandler sqlHandler = pm.GetSqlPassThroughHandler())
347 ················{
348 ····················sqlHandler.BeginTransaction();
349 ····················sqlHandler.Execute( "DELETE FROM Mitarbeiter" );
350 ····················sqlHandler.Execute( "DELETE FROM Reise" );
351 ····················sqlHandler.CommitTransaction();
352 ················}
353 ················var startCount = Logger.FindLogsWith("Starting transaction").Count;
354 ················var commitCount = Logger.FindLogsWith("Committing transaction").Count;
355 ················Assert.That( startCount == 1, "1 Transaction should be started" );
356 ················Assert.That( commitCount == 1, "1 Transaction should be committed" );
357 ············}
358 ········}
359
360 ········[Test]
361 ········public void DirectSqlPassThroughWithCombinedStatementsDoesNotCommit()
362 ········{
363 ············var pm = PmFactory.NewPersistenceManager();
364
365 ············using (ISqlPassThroughHandler sqlHandler = pm.GetSqlPassThroughHandler())
366 ············{
367 ················sqlHandler.Execute( "DELETE FROM Mitarbeiter" );
368 ················sqlHandler.Execute( "DELETE FROM Reise" );
369 ············}
370
371 ············var commitCount = Logger.FindLogsWith("Committing transaction").Count;
372 ············Assert.That( commitCount == 0, "Transaction shouldn't be committed" );
373 ········}
374
375 ········[Test]
376 ········public void DirectSqlPassWithAbortWorks()
377 ········{
378 ············var pm = PmFactory.NewPersistenceManager();
379 ············var m = new Mitarbeiter();
380 ············pm.MakePersistent( m );
381 ············pm.Save();
382 ············pm.UnloadCache();
383
384 ············using (ISqlPassThroughHandler sqlHandler = pm.GetSqlPassThroughHandler())
385 ············{
386 ················sqlHandler.BeginTransaction();
387 ················sqlHandler.Execute( "DELETE FROM Mitarbeiter" );
388 ················pm.Abort();
389 ············}
390
391 ············pm = PmFactory.NewPersistenceManager();
392 ············bool hasRecords = new NDOQuery<Mitarbeiter>( pm ).Execute().Count > 0;
393 ············Assert.That( hasRecords, "At least one record should be present" );
394 ········}
395 ····}
396 }
397
New Commit (ab2cdbc)
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 NUnit.Framework;
24 using NDO;
25 using Reisekosten.Personal;
26 using NDO.Query;
27 using Reisekosten;
28 using Formfakten.TestLogger;
29
30 namespace NdoUnitTests
31 {
32 ····[TestFixture]
33 public class TransactionTests : NDOTest
34 ····{
35 ········[SetUp]
36 ········public void Setup()
37 ········{
38 ············Logger.ClearTestLogs();
39 ········}
40
41 ········[TearDown]
42 ········public void TearDown()
43 ········{
44 ············Logger.ClearTestLogs();
45 ············var pm = PmFactory.NewPersistenceManager();
46 ············NDOQuery<Mitarbeiter> q = new NDOQuery<Mitarbeiter>( pm );
47 ············pm.Delete( q.Execute() );
48 ········}
49
50
51 ········/*
52 ········forceCommit should be:
53 ········
54 ····················Query····Save····Save(true)
55 ········Optimistic····1········1········0
56 ········Pessimistic····0········1········0
57 ············
58 ········Deferred Mode············
59 ····················Query····Save····Save(true)
60 ········Optimistic····0········1········0
61 ········Pessimistic····0········1········0
62
63 ········ */
64
65 ········[Test]
66 ········public void TestIfQueryWithoutTransactionDoesNotStartAndNotCommit()
67 ········{
68 ············using (var pm = PmFactory.NewPersistenceManager())
69 ············{
70 ················pm.TransactionMode = TransactionMode.None;
71 ················new NDOQuery<Mitarbeiter>( pm ).Execute();
72 ················var startCount = Logger.FindLogsWith("Starting transaction").Count;
73 ················var commitCount = Logger.FindLogsWith("Committing transaction").Count;
74 ················Assert.That( startCount == 0, "Transaction shouldn't be started" );
75 ················Assert.That( commitCount == 0, "Transaction shouldn't be committed" );
76 ············}
77 ········}
78
79
80 ········[Test]
81 ········public void TestIfOptimisticQueryIsImmediatelyCommitted()
82 ········{
83 ············using (var pm = PmFactory.NewPersistenceManager())
84 ············{
85 ················pm.TransactionMode = TransactionMode.Optimistic;
86 ················new NDOQuery<Mitarbeiter>( pm ).Execute();
87 ················var commitCount = Logger.FindLogsWith("Committing transaction").Count;
88 ················Assert.That( commitCount > 0, "Transaction should be committed" );
89 ············}
90 ········}
91
92 ········[Test]
93 ········public void TestIfPessimisticQueryIsNotCommitted()
94 ········{
95 ············using (var pm = PmFactory.NewPersistenceManager())
96 ············{
97 ················pm.TransactionMode = TransactionMode.Pessimistic;
98 ················new NDOQuery<Mitarbeiter>( pm ).Execute();
99 ················var startCount = Logger.FindLogsWith("Starting transaction").Count;
100 ················var commitCount = Logger.FindLogsWith("Committing transaction").Count;
101 ················Assert.That( startCount > 0, "Transaction should be started" );
102 ················Assert.That( commitCount == 0, "Transaction shouldn't be committed" );
103 ············}
104 ········}
105
106 ········[Test]
107 ········public void TestIfOptimisticSaveIsCommitted()
108 ········{
109 ············using (var pm = PmFactory.NewPersistenceManager())
110 ············{
111 ················pm.TransactionMode = TransactionMode.Optimistic;
112 ················Mitarbeiter m = new Mitarbeiter();
113 ················pm.MakePersistent( m );
114 ················pm.Save();
115
116 ················var startCount = Logger.FindLogsWith("Starting transaction").Count;
117 ················var commitCount = Logger.FindLogsWith("Committing transaction").Count;
118 ················Assert.That( startCount > 0, "Transaction should be started" );
119 ················Assert.That( commitCount > 0, "Transaction should be committed" );
120 ············}
121 ········}
122
123 ········[Test]
124 ········public void TestIfPessimisticSaveIsCommitted()
125 ········{
126 ············using (var pm = PmFactory.NewPersistenceManager())
127 ············{
128 ················pm.TransactionMode = TransactionMode.Pessimistic;
129 ················Mitarbeiter m = new Mitarbeiter();
130 ················pm.MakePersistent( m );
131 ················pm.Save();
132
133 ················var startCount = Logger.FindLogsWith("Starting transaction").Count;
134 ················var commitCount = Logger.FindLogsWith("Committing transaction").Count;
135 ················Assert.That( startCount > 0, "Transaction should be started" );
136 ················Assert.That( commitCount > 0, "Transaction should be committed" );
137 ············}
138 ········}
139
140 ········[Test]
141 ········public void OptimisticQueryAndSaveShouldHaveTwoTransactions()
142 ········{
143 ············using (var pm = PmFactory.NewPersistenceManager())
144 ············{
145 ················pm.TransactionMode = TransactionMode.Optimistic;
146 ················new NDOQuery<Mitarbeiter>( pm ).Execute();
147 ················Mitarbeiter m = new Mitarbeiter();
148 ················pm.MakePersistent( m );
149 ················pm.Save();
150
151 ················var startCount = Logger.FindLogsWith("Starting transaction").Count;
152 ················var commitCount = Logger.FindLogsWith("Committing transaction").Count;
153 ················Assert.That( startCount == 2, "Two Transactions should be started" );
154 ················Assert.That( commitCount == 2, "Two Transactions should be committed" );
155 ············}
156 ········}
157
158 ········[Test]
159 ········public void PessimisticQueryAndSaveShouldHaveOneTransaction()
160 ········{
161 ············using (var pm = PmFactory.NewPersistenceManager())
162 ············{
163 ················pm.TransactionMode = TransactionMode.Pessimistic;
164 ················new NDOQuery<Mitarbeiter>( pm ).Execute();
165 ················Mitarbeiter m = new Mitarbeiter();
166 ················pm.MakePersistent( m );
167 ················pm.Save();
168
169 ················var startCount = Logger.FindLogsWith("Starting transaction").Count;
170 ················var commitCount = Logger.FindLogsWith("Committing transaction").Count;
171 ················Assert.That( startCount == 1, "One Transaction should be started" );
172 ················Assert.That( commitCount == 1, "One Transaction should be committed" );
173 ············}
174 ········}
175
176 ········[Test]
177 ········public void OptimisticDeferredSaveShouldNotCommit()
178 ········{
179 ············using (var pm = PmFactory.NewPersistenceManager())
180 ············{
181 ················pm.TransactionMode = TransactionMode.Optimistic;
182 ················Mitarbeiter m = new Mitarbeiter();
183 ················pm.MakePersistent( m );
184 ················pm.Save( true );
185
186 ················var startCount = Logger.FindLogsWith("Starting transaction").Count;
187 ················var commitCount = Logger.FindLogsWith("Committing transaction").Count;
188 ················Assert.That( startCount > 0, "Transaction should be started" );
189 ················Assert.That( commitCount == 0, "Transaction shouldn't be committed" );
190 ············}
191 ········}
192
193 ········[Test]
194 ········public void PessimisticDeferredSaveShouldNotCommit()
195 ········{
196 ············using (var pm = PmFactory.NewPersistenceManager())
197 ············{
198 ················pm.TransactionMode = TransactionMode.Pessimistic;
199 ················Mitarbeiter m = new Mitarbeiter();
200 ················pm.MakePersistent( m );
201 ················pm.Save( true );
202 ················var startCount = Logger.FindLogsWith("Starting transaction").Count;
203 ················var commitCount = Logger.FindLogsWith("Committing transaction").Count;
204 ················Assert.That( startCount > 0, "Transaction should be started" );
205 ················Assert.That( commitCount == 0, "Transaction shouldn't be committed" );
206 ············}
207 ········}
208
209 ········[Test]
210 ········public void OptimisticDeferredSaveAndQueryShouldNotCommit()
211 ········{
212 ············using (var pm = PmFactory.NewPersistenceManager())
213 ············{
214 ················pm.TransactionMode = TransactionMode.Optimistic;
215 ················Mitarbeiter m = new Mitarbeiter();
216 ················pm.MakePersistent( m );
217 ················pm.Save( true );
218 ················new NDOQuery<Mitarbeiter>( pm ).Execute();
219
220 ················var startCount = Logger.FindLogsWith("Starting transaction").Count;
221 ················var commitCount = Logger.FindLogsWith("Committing transaction").Count;
222 ················Assert.That( startCount > 0, "Transaction should be started" );
223 ················Assert.That( commitCount == 0, "Transaction shouldn't be committed" );
224 ············}
225 ········}
226
227 ········[Test]
228 ········public void PessimisticDeferredSaveAndQueryShouldNotCommit()
229 ········{
230 ············using (var pm = PmFactory.NewPersistenceManager())
231 ············{
232 ················pm.TransactionMode = TransactionMode.Pessimistic;
233 ················Mitarbeiter m = new Mitarbeiter();
234 ················pm.MakePersistent( m );
235 ················pm.Save( true );
236 ················new NDOQuery<Mitarbeiter>( pm ).Execute();
237
238 ················var startCount = Logger.FindLogsWith("Starting transaction").Count;
239 ················var commitCount = Logger.FindLogsWith("Committing transaction").Count;
240 ················Assert.That( startCount > 0, "Transaction should be started" );
241 ················Assert.That( commitCount == 0, "Transaction shouldn't be committed" );
242 ············}
243 ········}
244
245 ········[Test]
246 ········public void OptimisticSaveAfterDeferredSaveShouldCommit()
247 ········{
248 ············using (var pm = PmFactory.NewPersistenceManager())
249 ············{
250 ················pm.TransactionMode = TransactionMode.Optimistic;
251 ················Mitarbeiter m = new Mitarbeiter();
252 ················pm.MakePersistent( m );
253 ················pm.Save( true );
254 ················m.Nachname = "Test";
255 ················pm.Save();
256
257 ················var startCount = Logger.FindLogsWith("Starting transaction").Count;
258 ················var commitCount = Logger.FindLogsWith("Committing transaction").Count;
259 ················Assert.That( startCount == 1, "Transaction should be started" );
260 ················Assert.That( commitCount == 1, "Transaction should be committed" );
261 ············}
262 ········}
263
264 ········[Test]
265 ········public void PessimisticSaveAfterDeferredSaveShouldCommit()
266 ········{
267 ············using (var pm = PmFactory.NewPersistenceManager())
268 ············{
269 ················pm.TransactionMode = TransactionMode.Pessimistic;
270 ················Mitarbeiter m = new Mitarbeiter();
271 ················pm.MakePersistent( m );
272 ················pm.Save( true );
273 ················m.Nachname = "Test";
274 ················pm.Save();
275
276 ················var startCount = Logger.FindLogsWith("Starting transaction").Count;
277 ················var commitCount = Logger.FindLogsWith("Committing transaction").Count;
278 ················Assert.That( startCount == 1, "Transaction should be started" );
279 ················Assert.That( commitCount == 1, "Transaction should be committed" );
280 ············}
281 ········}
282
283
284 ········[Test]
285 ········public void DirectSqlPassThroughWithoutTransactionShouldNotCommit()
286 ········{
287 ············using (var pm = PmFactory.NewPersistenceManager())
288 ············{
289 ················pm.TransactionMode = TransactionMode.None;
290 ················using (ISqlPassThroughHandler sqlHandler = pm.GetSqlPassThroughHandler())
291 ················{
292 ····················var reader = sqlHandler.Execute( "DELETE FROM Mitarbeiter" );
293 ····················Assert.That( reader == null, "Reader should be null" );
294 ················}
295
296 ················var startCount = Logger.FindLogsWith("Starting transaction").Count;
297 ················var commitCount = Logger.FindLogsWith("Committing transaction").Count;
298 ················Assert.That( startCount == 0, "Transaction shouldn't be started" );
299 ················Assert.That( commitCount == 0, "Transaction shouldn't be committed" );
300 ············}
301 ········}
302
303 ········int FlughafenCount( PersistenceManager pm )
304 ········{
305 ············NDOQuery<Flughafen> q = new NDOQuery<Flughafen>( pm );
306 ············return (int) (decimal) q.ExecuteAggregate( "oid", AggregateType.Count );
307 ········}
308
309 ········int LänderCount( PersistenceManager pm )
310 ········{
311 ············NDOQuery<Land> q = new NDOQuery<Land>( pm );
312 ············return (int) (decimal) q.ExecuteAggregate( "oid", AggregateType.Count );
313 ········}
314
315 ········[Test]
316 ········public void AbortedDeferredMultiStepTransactionDoesNotCommit()
317 ········{
318 ············using (var pm = PmFactory.NewPersistenceManager())
319 ············{
320 ················var landCount = LänderCount( pm );
321 ················var fhCount = FlughafenCount( pm );
322
323 ················pm.TransactionMode = TransactionMode.Optimistic;
324
325 ················Land land = new Land();
326 ················land.Name = "Germany";
327 ················pm.MakePersistent( land );
328 ················pm.Save( true );
329
330 ················var flughafen = new Flughafen();
331 ················flughafen.Kürzel = "MUC";
332 ················pm.MakePersistent( flughafen );
333 ················land.AddFlughafen( flughafen );
334 ················pm.Save( true );
335
336 ················pm.Abort();
337
338 ················Assert.That( landCount == LänderCount( pm ) );
339 ················Assert.That( fhCount == FlughafenCount( pm ) );
340 ············}
341 ········}
342
343 ········[Test]
344 ········public void DirectSqlPassThroughWithTransactionShouldCommit()
345 ········{
346 ············using (var pm = PmFactory.NewPersistenceManager())
347 ············{
348 ················using (ISqlPassThroughHandler sqlHandler = pm.GetSqlPassThroughHandler())
349 ················{
350 ····················sqlHandler.BeginTransaction();
351 ····················sqlHandler.Execute( "DELETE FROM Mitarbeiter" );
352 ····················sqlHandler.Execute( "DELETE FROM Reise" );
353 ····················sqlHandler.CommitTransaction();
354 ················}
355 ················var startCount = Logger.FindLogsWith("Starting transaction").Count;
356 ················var commitCount = Logger.FindLogsWith("Committing transaction").Count;
357 ················Assert.That( startCount == 1, "1 Transaction should be started" );
358 ················Assert.That( commitCount == 1, "1 Transaction should be committed" );
359 ············}
360 ········}
361
362 ········[Test]
363 ········public void DirectSqlPassThroughWithCombinedStatementsDoesNotCommit()
364 ········{
365 ············var pm = PmFactory.NewPersistenceManager();
366
367 ············using (ISqlPassThroughHandler sqlHandler = pm.GetSqlPassThroughHandler())
368 ············{
369 ················sqlHandler.Execute( "DELETE FROM Mitarbeiter" );
370 ················sqlHandler.Execute( "DELETE FROM Reise" );
371 ············}
372
373 ············var commitCount = Logger.FindLogsWith("Committing transaction").Count;
374 ············Assert.That( commitCount == 0, "Transaction shouldn't be committed" );
375 ········}
376
377 ········[Test]
378 ········public void DirectSqlPassWithAbortWorks()
379 ········{
380 ············var pm = PmFactory.NewPersistenceManager();
381 ············var m = new Mitarbeiter();
382 ············pm.MakePersistent( m );
383 ············pm.Save();
384 ············pm.UnloadCache();
385
386 ············using (ISqlPassThroughHandler sqlHandler = pm.GetSqlPassThroughHandler())
387 ············{
388 ················sqlHandler.BeginTransaction();
389 ················sqlHandler.Execute( "DELETE FROM Mitarbeiter" );
390 ················pm.Abort();
391 ············}
392
393 ············pm = PmFactory.NewPersistenceManager();
394 ············bool hasRecords = new NDOQuery<Mitarbeiter>( pm ).Execute().Count > 0;
395 ············Assert.That( hasRecords, "At least one record should be present" );
396 ········}
397 ····}
398 }
399