FutureQueryFixture.cs

//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by AsyncGenerator.
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------


using System.Linq;
using NHibernate.Driver;
using NHibernate.Linq;
using NUnit.Framework;

namespace NHibernate.Test.Futures
{
	using System.Threading.Tasks;
	[TestFixture]
	public class FutureQueryFixtureAsync : FutureFixture
	{
		protected override void OnTearDown()
		{
			using (var session = OpenSession())
			using (var transaction = session.BeginTransaction())
			{
				session.Delete("from Person");
				transaction.Commit();
			}
		}

		[Test]
		public async Task DefaultReadOnlyTestAsync()
		{
			CreatePersons();

			//NH-3575
			using (var s = Sfi.OpenSession())
			{
				s.DefaultReadOnly = true;

				var persons = s.CreateQuery("from Person").Future<Person>();

				Assert.IsTrue((await (persons.GetEnumerableAsync())).All(p => s.IsReadOnly(p)));
			}
		}

		[Test]
		public async Task CanUseFutureQueryAsync()
		{
			using (var s = Sfi.OpenSession())
			{
				IgnoreThisTestIfMultipleQueriesArentSupportedByDriver();

				var persons10 = s.CreateQuery("from Person")
					.SetMaxResults(10)
					.Future<Person>();
				var persons5 = s.CreateQuery("from Person")
					.SetMaxResults(5)
					.Future<int>();

				using (var logSpy = new SqlLogSpy())
				{
					foreach (var person in await (persons5.GetEnumerableAsync()))
					{
					}

					foreach (var person in await (persons10.GetEnumerableAsync()))
					{
					}

					var events = logSpy.Appender.GetEvents();
					Assert.AreEqual(1, events.Length);
				}
			}
		}

		[Test]
		public async Task TwoFuturesRunInTwoRoundTripsAsync()
		{
			using (var s = Sfi.OpenSession())
			{
				IgnoreThisTestIfMultipleQueriesArentSupportedByDriver();

				using (var logSpy = new SqlLogSpy())
				{
					var persons10 = s.CreateQuery("from Person")
						.SetMaxResults(10)
						.Future<Person>();

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

					var persons5 = s.CreateQuery("from Person")
						.SetMaxResults(5)
						.Future<int>();

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

					var events = logSpy.Appender.GetEvents();
					Assert.AreEqual(2, events.Length);
				}
			}
		}

		[Test]
		public async Task CanCombineSingleFutureValueWithEnumerableFuturesAsync()
		{
			using (var s = Sfi.OpenSession())
			{
				IgnoreThisTestIfMultipleQueriesArentSupportedByDriver();

				var persons = s.CreateQuery("from Person")
					.SetMaxResults(10)
					.Future<Person>();

				var personCount = s.CreateQuery("select count(*) from Person")
					.FutureValue<long>();

				using (var logSpy = new SqlLogSpy())
				{
					long count = await (personCount.GetValueAsync());

					foreach (var person in await (persons.GetEnumerableAsync()))
					{
					}

					var events = logSpy.Appender.GetEvents();
					Assert.AreEqual(1, events.Length);
				}
			}
		}

		[Test]
		public async Task CanExecuteMultipleQueryWithSameParameterNameAsync()
		{
			using (var s = Sfi.OpenSession())
			{
				IgnoreThisTestIfMultipleQueriesArentSupportedByDriver();

				var meContainer = s.CreateQuery("from Person p where p.Id = :personId")
					.SetParameter("personId", 1)
					.FutureValue<Person>();

				var possiblefriends = s.CreateQuery("from Person p where p.Id != :personId")
					.SetParameter("personId", 2)
					.Future<Person>();

				using (var logSpy = new SqlLogSpy())
				{
					var me = await (meContainer.GetValueAsync());

					foreach (var person in await (possiblefriends.GetEnumerableAsync()))
					{
					}

					var events = logSpy.Appender.GetEvents();
					Assert.AreEqual(1, events.Length);
					var wholeLog = logSpy.GetWholeLog();
					string paramPrefix = ((DriverBase) Sfi.ConnectionProvider.Driver).NamedPrefix;
					Assert.That(
						wholeLog,
						Does.Contain(paramPrefix + "p0 = 1 [Type: Int32 (0:0:0)], " + paramPrefix + "p1 = 2 [Type: Int32 (0:0:0)]"));
				}
			}
		}

		[Test]
		public async Task FutureExecutedOnGetEnumerableAsync()
		{
			Sfi.Statistics.IsStatisticsEnabled = true;
			try
			{
				using (var s = Sfi.OpenSession())
				{
					var persons = s.CreateQuery("from Person").Future<Person>();
					Sfi.Statistics.Clear();
					await (persons.GetEnumerableAsync());
					Assert.That(Sfi.Statistics.PrepareStatementCount, Is.EqualTo(1));
				}
			}
			finally
			{
				Sfi.Statistics.IsStatisticsEnabled = false;
			}
		}

		//NH-1953 - Future<> doesn't work on CreateFilter
		[Test]
		public async Task FutureOnFilterAsync()
		{
			CreatePersons();

			using (var s = Sfi.OpenSession())
			{
				var person = await (s.Query<Person>().Where(n => n.Name == "ParentTwoChildren").FirstOrDefaultAsync());

				var f1 = (await (s.CreateFilterAsync(person.Children, "where Age > 30"))).Future<Person>();
				var f2 = (await (s.CreateFilterAsync(person.Children, "where Age > 5"))).Future<Person>();

				Assert.That(person.Children.Count, Is.EqualTo(2), "invalid test set up");
				Assert.That((await (f1.GetEnumerableAsync())).ToList().Count, Is.EqualTo(0), "Invalid filtered results");
				Assert.That((await (f2.GetEnumerableAsync())).ToList().Count, Is.EqualTo(1), "Invalid filtered results");
			}
		}
	}
}