Datei: IntegrationTests/IntegrationTests/QueryCacheTests.cs

Last Commit (182cfd7)
1 using NDO. Logging;
2 using NUnit.Framework;
3 using Reisekosten.Personal;
4 using System;
5 using System.Collections.Generic;
6 using System.Linq;
7 using System.Text;
8 using System.Threading.Tasks;
9
10 namespace NdoUnitTests
11 {
12 ····[TestFixture]
13 public class QueryCacheTests
 
 
14 ····{
 
15 ········void CreateObject()
16 ········{
17 ············var pm = PmFactory.NewPersistenceManager();
18 ············Mitarbeiter m = new Mitarbeiter();
19 ············m.Vorname = "Mirko";
20 ············m.Nachname = "Matytschak";
21 ············pm.MakePersistent( m );
22 ············pm.Save();
23 ········}
24
25 ········[TearDown]
26 ········public void TearDown()
27 ········{
28 ············var pm = PmFactory.NewPersistenceManager();
29 ············pm.Objects<Mitarbeiter>().DeleteDirectly();
 
30 ········}
31
32 ········[Test]
33 ········public void TestSimpleQuery()
34 ········{
35 ············CreateObject();
36 ············var pm = PmFactory.NewPersistenceManager();
37 ············Assert.That( pm.QueryCache.Count, Is.EqualTo( 0 ) );
38 ············pm.UseQueryCache = true;
39 ············var result = pm.Objects<Mitarbeiter>().ResultTable;
40 ············Assert.That( result.Count == 1 );
41 ············Assert.That( pm.QueryCache.Count, Is.EqualTo( 1 ) );
42 ············pm.VerboseMode = true;
43 ············var testAdapter = new TestLogAdapter();
44 ············pm.LogAdapter = testAdapter;
45 ············result = pm.Objects<Mitarbeiter>().ResultTable;
46 ············Assert.That( result.Count == 1 );
47 Assert. That( testAdapter. Text. Trim( ) == "Getting results from QueryCache" ) ;
 
48 ········}
49
50 ········[Test]
51 ········public void QueryCacheCanBeSwitchedOff()
52 ········{
53 ············CreateObject();
54 ············var pm = PmFactory.NewPersistenceManager();
55 ············Assert.That( pm.QueryCache.Count, Is.EqualTo( 0 ) );
56 ············pm.UseQueryCache = false;
57 ············var result = pm.Objects<Mitarbeiter>().ResultTable;
58 ············Assert.That( result.Count == 1 );
59 ············Assert.That( pm.QueryCache.Count, Is.EqualTo( 0 ) );
60 ············pm.VerboseMode = true;
61 ············var testAdapter = new TestLogAdapter();
62 ············pm.LogAdapter = testAdapter;
63 ············result = pm.Objects<Mitarbeiter>().ResultTable;
64 ············Assert.That( result.Count == 1 );
65 Assert. That( testAdapter. Text. IndexOf( "QueryCache" ) == -1 ) ;
 
66 ········}
67
68 ········[Test]
69 ········public void DifferentQueryDoesntUseTheCache()
70 ········{
71 ············CreateObject();
72 ············var pm = PmFactory.NewPersistenceManager();
73 ············Assert.That( pm.QueryCache.Count, Is.EqualTo( 0 ) );
74 ············pm.UseQueryCache = true;
75 ············var result = pm.Objects<Mitarbeiter>().ResultTable;
76 ············Assert.That( result.Count == 1 );
77 ············Assert.That( pm.QueryCache.Count, Is.EqualTo( 1 ) );
78 ············pm.VerboseMode = true;
79 ············var testAdapter = new TestLogAdapter();
80 ············pm.LogAdapter = testAdapter;
81 ············result = pm.Objects<Mitarbeiter>().Where(m=>m.Vorname == "Mirko").ResultTable;
82 ············Assert.That( result.Count == 1 );
83 Assert. That( testAdapter. Text. IndexOf( "QueryCache" ) == -1 ) ;
 
84 ········}
85
86 ········[Test]
87 ········public void TakeAndSkipDontUseTheSameCacheResult()
88 ········{
89 ············CreateObject();
90 ············var pm = PmFactory.NewPersistenceManager();
91 ············Assert.That( pm.QueryCache.Count, Is.EqualTo( 0 ) );
92 ············pm.UseQueryCache = true;
93 ············var result = pm.Objects<Mitarbeiter>().OrderBy(m=>m.Nachname).Skip(0).Take(1).ResultTable;
94 ············Assert.That( result.Count == 1 );
95 ············Assert.That( pm.QueryCache.Count, Is.EqualTo( 1 ) );
96 ············pm.VerboseMode = true;
97 ············var testAdapter = new TestLogAdapter();
98 ············pm.LogAdapter = testAdapter;
99 ············result = pm.Objects<Mitarbeiter>().OrderBy(m=>m.Nachname).Skip(0).Take(2).ResultTable;
100 ············Assert.That( result.Count == 1 );
101 Assert. That( testAdapter. Text. IndexOf( "QueryCache" ) == -1 ) ;
 
102 ········}
103 ····}
104 }
105
New Commit (a04c7be)
1 using Formfakten. TestLogger;
2 using NUnit.Framework;
3 using Reisekosten.Personal;
 
 
 
 
 
4
5 namespace NdoUnitTests
6 {
7 ····[TestFixture]
8 public class QueryCacheTests : NDOTest
9 ····{
10 ········public QueryCacheTests()
11 ········{
12 ········}
13 ········void CreateObject()
14 ········{
15 ············var pm = PmFactory.NewPersistenceManager();
16 ············Mitarbeiter m = new Mitarbeiter();
17 ············m.Vorname = "Mirko";
18 ············m.Nachname = "Matytschak";
19 ············pm.MakePersistent( m );
20 ············pm.Save();
21 ········}
22
23 ········[TearDown]
24 ········public void TearDown()
25 ········{
26 ············var pm = PmFactory.NewPersistenceManager();
27 ············pm.Objects<Mitarbeiter>().DeleteDirectly();
28 ············Logger.ClearTestLogs();
29 ········}
30
31 ········[Test]
32 ········public void TestSimpleQuery()
33 ········{
34 ············CreateObject();
35 ············var pm = PmFactory.NewPersistenceManager();
36 ············Assert.That( pm.QueryCache.Count, Is.EqualTo( 0 ) );
37 ············pm.UseQueryCache = true;
38 ············var result = pm.Objects<Mitarbeiter>().ResultTable;
39 ············Assert.That( result.Count == 1 );
40 ············Assert.That( pm.QueryCache.Count, Is.EqualTo( 1 ) );
 
 
 
41 ············result = pm.Objects<Mitarbeiter>().ResultTable;
42 ············Assert.That( result.Count == 1 );
43 var logs = Logger. FindLogsWith( "Getting results from QueryCache" ) ;
44 ············Assert.That( logs.Count > 0 );
45 ········}
46
47 ········[Test]
48 ········public void QueryCacheCanBeSwitchedOff()
49 ········{
50 ············CreateObject();
51 ············var pm = PmFactory.NewPersistenceManager();
52 ············Assert.That( pm.QueryCache.Count, Is.EqualTo( 0 ) );
53 ············pm.UseQueryCache = false;
54 ············var result = pm.Objects<Mitarbeiter>().ResultTable;
55 ············Assert.That( result.Count == 1 );
56 ············Assert.That( pm.QueryCache.Count, Is.EqualTo( 0 ) );
 
 
 
57 ············result = pm.Objects<Mitarbeiter>().ResultTable;
58 ············Assert.That( result.Count == 1 );
59 var logs = Logger. FindLogsWith( "QueryCache" ) ;
60 ············Assert.That( logs.Count == 0 );
61 ········}
62
63 ········[Test]
64 ········public void DifferentQueryDoesntUseTheCache()
65 ········{
66 ············CreateObject();
67 ············var pm = PmFactory.NewPersistenceManager();
68 ············Assert.That( pm.QueryCache.Count, Is.EqualTo( 0 ) );
69 ············pm.UseQueryCache = true;
70 ············var result = pm.Objects<Mitarbeiter>().ResultTable;
71 ············Assert.That( result.Count == 1 );
72 ············Assert.That( pm.QueryCache.Count, Is.EqualTo( 1 ) );
 
 
 
73 ············result = pm.Objects<Mitarbeiter>().Where(m=>m.Vorname == "Mirko").ResultTable;
74 ············Assert.That( result.Count == 1 );
75 var logs = Logger. FindLogsWith( "QueryCache" ) ;
76 ············Assert.That( logs.Count == 0 );
77 ········}
78
79 ········[Test]
80 ········public void TakeAndSkipDontUseTheSameCacheResult()
81 ········{
82 ············CreateObject();
83 ············var pm = PmFactory.NewPersistenceManager();
84 ············Assert.That( pm.QueryCache.Count, Is.EqualTo( 0 ) );
85 ············pm.UseQueryCache = true;
86 ············var result = pm.Objects<Mitarbeiter>().OrderBy(m=>m.Nachname).Skip(0).Take(1).ResultTable;
87 ············Assert.That( result.Count == 1 );
88 ············Assert.That( pm.QueryCache.Count, Is.EqualTo( 1 ) );
 
 
 
89 ············result = pm.Objects<Mitarbeiter>().OrderBy(m=>m.Nachname).Skip(0).Take(2).ResultTable;
90 ············Assert.That( result.Count == 1 );
91 var logs = Logger. FindLogsWith( "QueryCache" ) ;
92 ············Assert.That( logs.Count == 0 );
93 ········}
94 ····}
95 }
96