Generate async files

Author: github-actions[bot]

src/NHibernate.Test/Async/CacheTest/CacheFixture.cs

@@ -22,7 +22,7 @@ namespace NHibernate.Test.CacheTest
 	public class CacheFixtureAsync: TestCase
 	{
 		[Test]
-		public async Task TestSimpleCacheAsync()
+		public async Task TestSimpleReadWriteCacheAsync()
 		{
 			await (DoTestCacheAsync(new HashtableCacheProvider()));
 		}
@@ -57,7 +57,8 @@ protected CacheKey CreateCacheKey(string text)
 
 			Assert.IsNull(await (ccs.GetAsync(fooKey, longBefore, cancellationToken)));
 			Assert.AreEqual("foo", await (ccs.GetAsync(fooKey, after, cancellationToken)));
-			Assert.IsFalse(await (ccs.PutAsync(fooKey, "foo", before, null, null, false, cancellationToken)));
+			Assert.IsFalse(await (ccs.PutAsync(fooKey, "foo", before, null, null, true, cancellationToken)));
+			Assert.IsTrue(await (ccs.PutAsync(fooKey, "foo", before, null, null, false, cancellationToken)));
 
 			// update it;
 

src/NHibernate.Test/Async/NHSpecificTest/GH2552/Fixture.cs

@@ -27,6 +27,7 @@ protected override void Configure(NHCfg.Configuration configuration)
 		{
 			configuration.SetProperty(NHCfg.Environment.UseSecondLevelCache, "true");
 			configuration.SetProperty(NHCfg.Environment.GenerateStatistics, "true");
+			configuration.SetProperty(NHCfg.Environment.UseMinimalPuts, "true");
 		}
 
 		protected override void OnTearDown()

src/NHibernate.Test/Async/NHSpecificTest/GH3176/FixtureByCode.cs

@@ -0,0 +1,181 @@
+//------------------------------------------------------------------------------
+// <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.Cache;
+using NHibernate.Cfg;
+using NHibernate.Cfg.MappingSchema;
+using NHibernate.Linq;
+using NHibernate.Mapping.ByCode;
+using NUnit.Framework;
+
+namespace NHibernate.Test.NHSpecificTest.GH3176
+{
+	using System.Threading.Tasks;
+	[TestFixture(CacheFactory.ReadOnly, false)]
+	[TestFixture(CacheFactory.NonstrictReadWrite, false)]
+	[TestFixture(CacheFactory.ReadWrite, false)]
+	[TestFixture(CacheFactory.ReadWrite, true)]
+	public class ByCodeFixtureAsync : TestCaseMappingByCode
+	{
+		private readonly bool _versioned;
+
+		public ByCodeFixtureAsync(string cacheStrategy, bool versioned)
+		{
+			_versioned = versioned;
+			CacheConcurrencyStrategy = cacheStrategy;
+		}
+
+		protected override string CacheConcurrencyStrategy { get; }
+
+		private int _id;
+
+		protected override HbmMapping GetMappings()
+		{
+			var mapper = new ModelMapper();
+			mapper.Class<Entity>(
+				rc =>
+				{
+					rc.Id(x => x.Id, m => m.Generator(Generators.Identity));
+					rc.Property(x => x.Name);
+					rc.Component(
+						x => x.Component,
+						m =>
+						{
+							m.Property(x => x.Field);
+							m.Lazy(true);
+						});
+					if (_versioned)
+						rc.Version(x => x.Version, m => { });
+				});
+
+			return mapper.CompileMappingForAllExplicitlyAddedEntities();
+		}
+
+		protected override void Configure(Configuration configuration)
+		{
+			base.Configure(configuration);
+			configuration.Properties[Environment.CacheProvider] = typeof(HashtableCacheProvider).AssemblyQualifiedName;
+			configuration.Properties[Environment.UseSecondLevelCache] = "true";
+			configuration.Properties[Environment.GenerateStatistics] = "true";
+		}
+
+		protected override void OnSetUp()
+		{
+			using (var session = OpenSession())
+			using (var transaction = session.BeginTransaction())
+			{
+				var e1 = new Entity { Name = "Bob", Component = new Component() { Field = "Jim" } };
+				session.Save(e1);
+				_id = e1.Id;
+
+				var e2 = new Entity { Name = "Sally" };
+				session.Save(e2);
+
+				transaction.Commit();
+			}
+		}
+
+		protected override void OnTearDown()
+		{
+			using (var session = OpenSession())
+			using (var transaction = session.BeginTransaction())
+			{
+				session.CreateQuery("delete from Entity").ExecuteUpdate();
+				transaction.Commit();
+			}
+		}
+
+		[Test]
+		public async Task TestPreLoadedDataAsync()
+		{
+			using (var session = OpenSession())
+			using (var transaction = session.BeginTransaction())
+			{
+				// Load the entities into the second-level cache.
+				await (session.Query<Entity>().WithOptions(o => o.SetCacheable(true)).ToListAsync());
+
+				var result = await (session.Query<Entity>().WithOptions(o => o.SetCacheable(true)).Fetch(e => e.Component).FirstAsync());
+
+				Assert.That(NHibernateUtil.IsPropertyInitialized(result, "Component"), Is.True);
+
+				var field = result.Component?.Field;
+
+				Assert.That(field, Is.EqualTo("Jim"));
+			}
+
+			using (var session = OpenSession())
+			using (var transaction = session.BeginTransaction())
+			{
+				var result = await (session.Query<Entity>().WithOptions(o => o.SetCacheable(true)).Fetch(e => e.Component).FirstAsync());
+
+				Assert.That(NHibernateUtil.IsPropertyInitialized(result, "Component"), Is.True);
+
+				var field = result.Component?.Field;
+
+				Assert.That(field, Is.EqualTo("Jim"));
+			}
+		}
+
+		[Test]
+		public async Task InitializedLazyPropertyShouldBeCachedAsync()
+		{
+			using (var session = OpenSession())
+			using (var transaction = session.BeginTransaction())
+			{
+				var e = await (session.GetAsync<Entity>(_id));
+				Assert.That(e.Component?.Field, Is.EqualTo("Jim"));
+
+				Assert.That(NHibernateUtil.IsPropertyInitialized(e, "Component"), Is.True);
+				await (transaction.CommitAsync());
+			}
+
+			using (var session = OpenSession())
+			using (var transaction = session.BeginTransaction())
+			{
+				var e = await (session.GetAsync<Entity>(_id));
+
+				Assert.That(NHibernateUtil.IsPropertyInitialized(e, "Component"), Is.True, "Lazy property is not cached");
+				var field = e.Component?.Field;
+
+				Assert.That(field, Is.EqualTo("Jim"));
+				await (transaction.CommitAsync());
+			}
+		}
+
+		[Test]
+		public async Task TestNonPreLoadedDataAsync()
+		{
+			using (var session = OpenSession())
+			using (var transaction = session.BeginTransaction())
+			{
+				var result = await (session.Query<Entity>().WithOptions(o => o.SetCacheable(true)).Fetch(e => e.Component).FirstAsync());
+
+				Assert.That(NHibernateUtil.IsPropertyInitialized(result, "Component"), Is.True);
+
+				var field = result.Component?.Field;
+
+				Assert.That(field, Is.EqualTo("Jim"));
+			}
+
+			using (var session = OpenSession())
+			using (var transaction = session.BeginTransaction())
+			{
+				var result = await (session.Query<Entity>().WithOptions(o => o.SetCacheable(true)).Fetch(e => e.Component).FirstAsync());
+
+				Assert.That(NHibernateUtil.IsPropertyInitialized(result, "Component"), Is.True);
+
+				var field = result.Component?.Field;
+
+				Assert.That(field, Is.EqualTo("Jim"));
+			}
+		}
+	}
+}

src/NHibernate/Async/Cache/ReadWriteCache.cs

@@ -8,6 +8,7 @@
 //------------------------------------------------------------------------------
 
 
+using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
@@ -18,6 +19,7 @@ namespace NHibernate.Cache
 {
 	using System.Threading.Tasks;
 	using System.Threading;
+
 	public partial class ReadWriteCache : IBatchableCacheConcurrencyStrategy
 	{
 
@@ -264,7 +266,7 @@ private Task DecrementLockAsync(object key, CacheLock @lock, CancellationToken c
 				@lock.Unlock(Cache.NextTimestamp());
 				return Cache.PutAsync(key, @lock, cancellationToken);
 			}
-			catch (System.Exception ex)
+			catch (Exception ex)
 			{
 				return Task.FromException<object>(ex);
 			}
@@ -315,7 +317,7 @@ internal Task HandleLockExpiryAsync(object key, CancellationToken cancellationTo
 				@lock.Unlock(ts);
 				return Cache.PutAsync(key, @lock, cancellationToken);
 			}
-			catch (System.Exception ex)
+			catch (Exception ex)
 			{
 				return Task.FromException<object>(ex);
 			}
@@ -436,7 +438,7 @@ public Task EvictAsync(CacheKey key, CancellationToken cancellationToken)
 				Evict(key);
 				return Task.CompletedTask;
 			}
-			catch (System.Exception ex)
+			catch (Exception ex)
 			{
 				return Task.FromException<object>(ex);
 			}
@@ -452,7 +454,7 @@ public Task<bool> UpdateAsync(CacheKey key, object value, object currentVersion,
 			{
 				return Task.FromResult<bool>(Update(key, value, currentVersion, previousVersion));
 			}
-			catch (System.Exception ex)
+			catch (Exception ex)
 			{
 				return Task.FromException<bool>(ex);
 			}