BatcherFixture.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 NHibernate.AdoNet;
using NHibernate.Cfg;
using NUnit.Framework;

namespace NHibernate.Test.Ado
{
	using System.Threading.Tasks;
	using System.Threading;
	[TestFixture]
	public class BatcherFixtureAsync: TestCase
	{
		protected override string MappingsAssembly
		{
			get { return "NHibernate.Test"; }
		}

		protected override string[] Mappings
		{
			get { return new[] { "Ado.VerySimple.hbm.xml", "Ado.AlmostSimple.hbm.xml" }; }
		}

		protected override void Configure(Configuration configuration)
		{
			configuration.SetProperty(Environment.FormatSql, "true");
			configuration.SetProperty(Environment.GenerateStatistics, "true");
			configuration.SetProperty(Environment.BatchSize, "10");
		}

		protected override bool AppliesTo(Engine.ISessionFactoryImplementor factory)
		{
			return !(factory.Settings.BatcherFactory is NonBatchingBatcherFactory);
		}

		[Test]
		[Description("The batcher should run all INSERT queries in only one roundtrip.")]
		public async Task OneRoundTripInsertsAsync()
		{
			Sfi.Statistics.Clear();
			await (FillDbAsync());

			Assert.That(Sfi.Statistics.PrepareStatementCount, Is.EqualTo(1));
			await (CleanupAsync());
		}

		private async Task CleanupAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			using (ISession s = Sfi.OpenSession())
			using (var t = s.BeginTransaction())
			{
				await (s.CreateQuery("delete from VerySimple").ExecuteUpdateAsync(cancellationToken));
				await (s.CreateQuery("delete from AlmostSimple").ExecuteUpdateAsync(cancellationToken));
				await (t.CommitAsync(cancellationToken));
			}
		}

		private async Task FillDbAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			using (ISession s = Sfi.OpenSession())
			using (ITransaction tx = s.BeginTransaction())
			{
				await (s.SaveAsync(new VerySimple {Id = 1, Name = "Fabio", Weight = 119.5}, cancellationToken));
				await (s.SaveAsync(new VerySimple {Id = 2, Name = "Fiamma", Weight = 9.8}, cancellationToken));
				await (s.SaveAsync(new VerySimple {Id = 3, Name = "Roberto", Weight = 98.8 }, cancellationToken));
				await (tx.CommitAsync(cancellationToken));
			}
		}

		[Test]
		[Description("The batcher should run all UPDATE queries in only one roundtrip.")]
		public async Task OneRoundTripUpdateAsync()
		{
			await (FillDbAsync());

			using (ISession s = Sfi.OpenSession())
			using (ITransaction tx = s.BeginTransaction())
			{
				var vs1 = await (s.GetAsync<VerySimple>(1));
				var vs2 = await (s.GetAsync<VerySimple>(2));
				var vs3 = await (s.GetAsync<VerySimple>(3));
				vs1.Weight -= 10;
				vs2.Weight -= 1;
				vs3.Weight -= 5;
				Sfi.Statistics.Clear();
				await (s.UpdateAsync(vs1));
				await (s.UpdateAsync(vs2));
				await (s.UpdateAsync(vs3));
				await (tx.CommitAsync());
			}

			Assert.That(Sfi.Statistics.PrepareStatementCount, Is.EqualTo(1));
			await (CleanupAsync());
		}

		[Test, NetFxOnly]
		[Description("SqlClient: The batcher log output should be formatted")]
		public async Task BatchedoutputShouldBeFormattedAsync()
		{
#if NETFX
			if (Sfi.Settings.BatcherFactory is SqlClientBatchingBatcherFactory == false)
				Assert.Ignore("This test is for SqlClientBatchingBatcher only");
#endif

			using (var sqlLog = new SqlLogSpy())
			{
				await (FillDbAsync());
				var log = sqlLog.GetWholeLog();
				Assert.IsTrue(log.Contains("INSERT \n    INTO"));
			}

			await (CleanupAsync());
		}

		[Test]
		[Description("The batcher should run all DELETE queries in only one roundtrip.")]
		public async Task OneRoundTripDeleteAsync()
		{
			await (FillDbAsync());

			using (ISession s = Sfi.OpenSession())
			using (ITransaction tx = s.BeginTransaction())
			{
				var vs1 = await (s.GetAsync<VerySimple>(1));
				var vs2 = await (s.GetAsync<VerySimple>(2));
				var vs3 = await (s.GetAsync<VerySimple>(3));
				Sfi.Statistics.Clear();
				await (s.DeleteAsync(vs1));
				await (s.DeleteAsync(vs2));
				await (s.DeleteAsync(vs3));
				await (tx.CommitAsync());
			}

			Assert.That(Sfi.Statistics.PrepareStatementCount, Is.EqualTo(1));
			await (CleanupAsync());
		}

		[Test]
		[Description(@"Activating the SQL and turning off the batcher's log the log stream:
-should not contains adding to batch
-should contain batch command
-the batcher should work.")]
		public async Task SqlLogAsync()
		{
			using (new LogSpy(typeof(AbstractBatcher), true))
			{
				using (var sl = new SqlLogSpy())
				{
					Sfi.Statistics.Clear();
					await (FillDbAsync());
					string logs = sl.GetWholeLog();
					Assert.That(logs, Does.Not.Contain("Adding to batch").IgnoreCase);
					Assert.That(logs, Does.Contain("Batch command").IgnoreCase);
					Assert.That(logs, Does.Contain("INSERT").IgnoreCase);
				}
			}

			Assert.That(Sfi.Statistics.PrepareStatementCount, Is.EqualTo(1));
			await (CleanupAsync());
		}

		[Test]
		[Description(@"Activating the AbstractBatcher's log the log stream:
-should not contains batch info 
-should contain SQL log info only regarding batcher (SQL log should not be duplicated)
-the batcher should work.")]
		public async Task AbstractBatcherLogAsync()
		{
			using (new LogSpy(typeof(AbstractBatcher)))
			{
				using (var sl = new SqlLogSpy())
				{
					Sfi.Statistics.Clear();
					await (FillDbAsync());
					string logs = sl.GetWholeLog();
					Assert.That(logs, Does.Contain("batch").IgnoreCase);
					foreach (var loggingEvent in sl.Appender.GetEvents())
					{
						string message = loggingEvent.RenderedMessage;
						if(message.ToLowerInvariant().Contains("insert"))
						{
							Assert.That(message, Does.Contain("batch").IgnoreCase);
						}
					}
				}
			}

			Assert.That(Sfi.Statistics.PrepareStatementCount, Is.EqualTo(1));
			await (CleanupAsync());
		}

		[Test]
		public async Task SqlLogShouldGetBatchCommandNotificationAsync()
		{
			using (new LogSpy(typeof(AbstractBatcher)))
			{
				using (var sl = new SqlLogSpy())
				{
					Sfi.Statistics.Clear();
					await (FillDbAsync());
					string logs = sl.GetWholeLog();
					Assert.That(logs, Does.Contain("Batch commands:").IgnoreCase);
				}
			}

			Assert.That(Sfi.Statistics.PrepareStatementCount, Is.EqualTo(1));
			await (CleanupAsync());
		}

		[Test]
		[Description(@"Activating the AbstractBatcher's log the log stream:
-should contain well formatted SQL log info")]
		public async Task AbstractBatcherLogFormattedSqlAsync()
		{
			using (new LogSpy(typeof(AbstractBatcher)))
			{
				using (var sl = new SqlLogSpy())
				{
					Sfi.Statistics.Clear();
					await (FillDbAsync());
					foreach (var loggingEvent in sl.Appender.GetEvents())
					{
						string message = loggingEvent.RenderedMessage;
						if(message.StartsWith("Adding"))
						{
							// should be the line with the formatted SQL
							var strings = message.Split(System.Environment.NewLine.ToCharArray());
							foreach (var sqlLine in strings)
							{
								if(sqlLine.Contains("p0"))
								{
									Assert.That(sqlLine, Does.Contain("p1"));
									Assert.That(sqlLine, Does.Contain("p2"));
								}
							}
						}
					}
				}
			}

			Assert.That(Sfi.Statistics.PrepareStatementCount, Is.EqualTo(1));
			await (CleanupAsync());
		}
	}
}