Skip to content

Commit 5df9626

Browse files
fredericDelaportehazzik
fredericDelaporte
authored and
hazzik
committed
NH-3905 - Regenerate Async
1 parent 73a9fec commit 5df9626

File tree

121 files changed

+13029
-685
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

121 files changed

+13029
-685
lines changed

‎src/NHibernate.Test/Async/Futures/FallbackFixture.cs

Lines changed: 29 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -70,8 +70,8 @@ public async Task FutureOfCriteriaFallsBackToListImplementationWhenQueryBatching
7070
{
7171
using (var session = Sfi.OpenSession())
7272
{
73-
var results = await (session.CreateCriteria<Person>().FutureAsync<Person>());
74-
results.GetEnumerator().MoveNext();
73+
var results = session.CreateCriteria<Person>().Future<Person>();
74+
(await (results.GetEnumerableAsync())).GetEnumerator().MoveNext();
7575
}
7676
}
7777

@@ -85,7 +85,7 @@ public async Task FutureValueOfCriteriaCanGetSingleEntityWhenQueryBatchingIsNotS
8585
var futurePerson = session.CreateCriteria<Person>()
8686
.Add(Restrictions.Eq("Id", personId))
8787
.FutureValue<Person>();
88-
Assert.IsNotNull(futurePerson.Value);
88+
Assert.IsNotNull(await (futurePerson.GetValueAsync()));
8989
}
9090
}
9191

@@ -99,7 +99,17 @@ public async Task FutureValueOfCriteriaCanGetScalarValueWhenQueryBatchingIsNotSu
9999
var futureCount = session.CreateCriteria<Person>()
100100
.SetProjection(Projections.RowCount())
101101
.FutureValue<int>();
102-
Assert.That(futureCount.Value, Is.EqualTo(1));
102+
Assert.That(await (futureCount.GetValueAsync()), Is.EqualTo(1));
103+
}
104+
}
105+
106+
[Test]
107+
public async Task FutureOfQueryFallsBackToListImplementationWhenQueryBatchingIsNotSupportedAsync()
108+
{
109+
using (var session = Sfi.OpenSession())
110+
{
111+
var results = session.CreateQuery("from Person").Future<Person>();
112+
(await (results.GetEnumerableAsync())).GetEnumerator().MoveNext();
103113
}
104114
}
105115

@@ -113,7 +123,7 @@ public async Task FutureValueOfQueryCanGetSingleEntityWhenQueryBatchingIsNotSupp
113123
var futurePerson = session.CreateQuery("from Person where Id = :id")
114124
.SetInt32("id", personId)
115125
.FutureValue<Person>();
116-
Assert.IsNotNull(futurePerson.Value);
126+
Assert.IsNotNull(await (futurePerson.GetValueAsync()));
117127
}
118128
}
119129

@@ -126,7 +136,17 @@ public async Task FutureValueOfQueryCanGetScalarValueWhenQueryBatchingIsNotSuppo
126136
{
127137
var futureCount = session.CreateQuery("select count(*) from Person")
128138
.FutureValue<long>();
129-
Assert.That(futureCount.Value, Is.EqualTo(1L));
139+
Assert.That(await (futureCount.GetValueAsync()), Is.EqualTo(1L));
140+
}
141+
}
142+
143+
[Test]
144+
public async Task FutureOfLinqFallsBackToListImplementationWhenQueryBatchingIsNotSupportedAsync()
145+
{
146+
using (var session = Sfi.OpenSession())
147+
{
148+
var results = session.Query<Person>().ToFuture();
149+
(await (results.GetEnumerableAsync())).GetEnumerator().MoveNext();
130150
}
131151
}
132152

@@ -140,7 +160,7 @@ public async Task FutureValueOfLinqCanGetSingleEntityWhenQueryBatchingIsNotSuppo
140160
var futurePerson = session.Query<Person>()
141161
.Where(x => x.Id == personId)
142162
.ToFutureValue();
143-
Assert.IsNotNull(futurePerson.Value);
163+
Assert.IsNotNull(await (futurePerson.GetValueAsync()));
144164
}
145165
}
146166

@@ -155,7 +175,7 @@ public async Task FutureValueWithSelectorOfLinqCanGetSingleEntityWhenQueryBatchi
155175
.Query<Person>()
156176
.Where(x => x.Id == personId)
157177
.ToFutureValue(q => q.FirstOrDefault());
158-
Assert.IsNotNull(futurePerson.Value);
178+
Assert.IsNotNull(await (futurePerson.GetValueAsync()));
159179
}
160180
}
161181

@@ -170,4 +190,4 @@ public async Task FutureValueWithSelectorOfLinqCanGetSingleEntityWhenQueryBatchi
170190
}
171191
}
172192
}
173-
}
193+
}

‎src/NHibernate.Test/Async/Futures/FutureCriteriaFixture.cs

Lines changed: 18 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -26,9 +26,9 @@ public async Task DefaultReadOnlyTestAsync()
2626
{
2727
s.DefaultReadOnly = true;
2828

29-
var persons = await (s.CreateCriteria(typeof(Person)).FutureAsync<Person>());
29+
var persons = s.CreateCriteria(typeof(Person)).Future<Person>();
3030

31-
Assert.IsTrue(persons.All(p => s.IsReadOnly(p)));
31+
Assert.IsTrue((await (persons.GetEnumerableAsync())).All(p => s.IsReadOnly(p)));
3232
}
3333
}
3434

@@ -39,21 +39,21 @@ public async Task CanUseFutureCriteriaAsync()
3939
{
4040
IgnoreThisTestIfMultipleQueriesArentSupportedByDriver();
4141

42-
var persons10 = await (s.CreateCriteria(typeof(Person))
42+
var persons10 = s.CreateCriteria(typeof(Person))
4343
.SetMaxResults(10)
44-
.FutureAsync<Person>());
45-
var persons5 = await (s.CreateCriteria(typeof(Person))
44+
.Future<Person>();
45+
var persons5 = s.CreateCriteria(typeof(Person))
4646
.SetMaxResults(5)
47-
.FutureAsync<int>());
47+
.Future<int>();
4848

4949
using (var logSpy = new SqlLogSpy())
5050
{
51-
foreach (var person in persons5)
51+
foreach (var person in await (persons5.GetEnumerableAsync()))
5252
{
5353

5454
}
5555

56-
foreach (var person in persons10)
56+
foreach (var person in await (persons10.GetEnumerableAsync()))
5757
{
5858

5959
}
@@ -73,17 +73,17 @@ public async Task TwoFuturesRunInTwoRoundTripsAsync()
7373

7474
using (var logSpy = new SqlLogSpy())
7575
{
76-
var persons10 = await (s.CreateCriteria(typeof(Person))
76+
var persons10 = s.CreateCriteria(typeof(Person))
7777
.SetMaxResults(10)
78-
.FutureAsync<Person>());
78+
.Future<Person>();
7979

80-
foreach (var person in persons10) { } // fire first future round-trip
80+
foreach (var person in await (persons10.GetEnumerableAsync())) { } // fire first future round-trip
8181

82-
var persons5 = await (s.CreateCriteria(typeof(Person))
82+
var persons5 = s.CreateCriteria(typeof(Person))
8383
.SetMaxResults(5)
84-
.FutureAsync<int>());
84+
.Future<int>();
8585

86-
foreach (var person in persons5) { } // fire second future round-trip
86+
foreach (var person in await (persons5.GetEnumerableAsync())) { } // fire second future round-trip
8787

8888
var events = logSpy.Appender.GetEvents();
8989
Assert.AreEqual(2, events.Length);
@@ -98,19 +98,19 @@ public async Task CanCombineSingleFutureValueWithEnumerableFuturesAsync()
9898
{
9999
IgnoreThisTestIfMultipleQueriesArentSupportedByDriver();
100100

101-
var persons = await (s.CreateCriteria(typeof(Person))
101+
var persons = s.CreateCriteria(typeof(Person))
102102
.SetMaxResults(10)
103-
.FutureAsync<Person>());
103+
.Future<Person>();
104104

105105
var personCount = s.CreateCriteria(typeof(Person))
106106
.SetProjection(Projections.RowCount())
107107
.FutureValue<int>();
108108

109109
using (var logSpy = new SqlLogSpy())
110110
{
111-
int count = personCount.Value;
111+
int count = await (personCount.GetValueAsync());
112112

113-
foreach (var person in persons)
113+
foreach (var person in await (persons.GetEnumerableAsync()))
114114
{
115115

116116
}

‎src/NHibernate.Test/Async/Futures/FutureQueryFixture.cs

Lines changed: 156 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,156 @@
1+
//------------------------------------------------------------------------------
2+
// <auto-generated>
3+
// This code was generated by AsyncGenerator.
4+
//
5+
// Changes to this file may cause incorrect behavior and will be lost if
6+
// the code is regenerated.
7+
// </auto-generated>
8+
//------------------------------------------------------------------------------
9+
10+
11+
using System.Linq;
12+
using NHibernate.Driver;
13+
using NUnit.Framework;
14+
15+
namespace NHibernate.Test.Futures
16+
{
17+
using System.Threading.Tasks;
18+
[TestFixture]
19+
public class FutureQueryFixtureAsync : FutureFixture
20+
{
21+
[Test]
22+
public async Task DefaultReadOnlyTestAsync()
23+
{
24+
//NH-3575
25+
using (var s = Sfi.OpenSession())
26+
{
27+
s.DefaultReadOnly = true;
28+
29+
var persons = s.CreateQuery("from Person").Future<Person>();
30+
31+
Assert.IsTrue((await (persons.GetEnumerableAsync())).All(p => s.IsReadOnly(p)));
32+
}
33+
}
34+
35+
[Test]
36+
public async Task CanUseFutureQueryAsync()
37+
{
38+
using (var s = Sfi.OpenSession())
39+
{
40+
IgnoreThisTestIfMultipleQueriesArentSupportedByDriver();
41+
42+
var persons10 = s.CreateQuery("from Person")
43+
.SetMaxResults(10)
44+
.Future<Person>();
45+
var persons5 = s.CreateQuery("from Person")
46+
.SetMaxResults(5)
47+
.Future<int>();
48+
49+
using (var logSpy = new SqlLogSpy())
50+
{
51+
foreach (var person in await (persons5.GetEnumerableAsync()))
52+
{
53+
54+
}
55+
56+
foreach (var person in await (persons10.GetEnumerableAsync()))
57+
{
58+
59+
}
60+
61+
var events = logSpy.Appender.GetEvents();
62+
Assert.AreEqual(1, events.Length);
63+
}
64+
}
65+
}
66+
67+
[Test]
68+
public async Task TwoFuturesRunInTwoRoundTripsAsync()
69+
{
70+
using (var s = Sfi.OpenSession())
71+
{
72+
IgnoreThisTestIfMultipleQueriesArentSupportedByDriver();
73+
74+
using (var logSpy = new SqlLogSpy())
75+
{
76+
var persons10 = s.CreateQuery("from Person")
77+
.SetMaxResults(10)
78+
.Future<Person>();
79+
80+
foreach (var person in await (persons10.GetEnumerableAsync())) { } // fire first future round-trip
81+
82+
var persons5 = s.CreateQuery("from Person")
83+
.SetMaxResults(5)
84+
.Future<int>();
85+
86+
foreach (var person in await (persons5.GetEnumerableAsync())) { } // fire second future round-trip
87+
88+
var events = logSpy.Appender.GetEvents();
89+
Assert.AreEqual(2, events.Length);
90+
}
91+
}
92+
}
93+
94+
[Test]
95+
public async Task CanCombineSingleFutureValueWithEnumerableFuturesAsync()
96+
{
97+
using (var s = Sfi.OpenSession())
98+
{
99+
IgnoreThisTestIfMultipleQueriesArentSupportedByDriver();
100+
101+
var persons = s.CreateQuery("from Person")
102+
.SetMaxResults(10)
103+
.Future<Person>();
104+
105+
var personCount = s.CreateQuery("select count(*) from Person")
106+
.FutureValue<long>();
107+
108+
using (var logSpy = new SqlLogSpy())
109+
{
110+
long count = await (personCount.GetValueAsync());
111+
112+
foreach (var person in await (persons.GetEnumerableAsync()))
113+
{
114+
}
115+
116+
var events = logSpy.Appender.GetEvents();
117+
Assert.AreEqual(1, events.Length);
118+
}
119+
}
120+
}
121+
122+
[Test]
123+
public async Task CanExecuteMultipleQueryWithSameParameterNameAsync()
124+
{
125+
using (var s = Sfi.OpenSession())
126+
{
127+
IgnoreThisTestIfMultipleQueriesArentSupportedByDriver();
128+
129+
var meContainer = s.CreateQuery("from Person p where p.Id = :personId")
130+
.SetParameter("personId", 1)
131+
.FutureValue<Person>();
132+
133+
var possiblefriends = s.CreateQuery("from Person p where p.Id != :personId")
134+
.SetParameter("personId", 2)
135+
.Future<Person>();
136+
137+
using (var logSpy = new SqlLogSpy())
138+
{
139+
var me = await (meContainer.GetValueAsync());
140+
141+
foreach (var person in await (possiblefriends.GetEnumerableAsync()))
142+
{
143+
}
144+
145+
var events = logSpy.Appender.GetEvents();
146+
Assert.AreEqual(1, events.Length);
147+
var wholeLog = logSpy.GetWholeLog();
148+
string paramPrefix = ((DriverBase) Sfi.ConnectionProvider.Driver).NamedPrefix;
149+
Assert.That(
150+
wholeLog,
151+
Does.Contain(paramPrefix + "p0 = 1 [Type: Int32 (0:0:0)], " + paramPrefix + "p1 = 2 [Type: Int32 (0:0:0)]"));
152+
}
153+
}
154+
}
155+
}
156+
}

0 commit comments

Comments
 (0)