Datei: IntegrationTests/IntegrationTests/TransactionScopeTests.cs

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