Stronger typing of invalidation methods.

Fixed assertions in unit test.

Author: gliljas

src/NHibernate.Test/SecondLevelCacheTest/InvalidationTests.cs

@@ -1,15 +1,12 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 using NHibernate.Cache;
 using NHibernate.Cfg;
 using NHibernate.Impl;
 using NHibernate.Test.SecondLevelCacheTests;
 using NSubstitute;
 using NUnit.Framework;
-using Environment = System.Environment;
 
 namespace NHibernate.Test.SecondLevelCacheTest
 {
@@ -23,8 +20,8 @@ public class InvalidationTests : TestCase
 		protected override void Configure(Configuration configuration)
 		{
 			base.Configure(configuration);
-			configuration.Properties[Cfg.Environment.CacheProvider] = typeof(HashtableCacheProvider).AssemblyQualifiedName;
-			configuration.Properties[Cfg.Environment.UseQueryCache] = "true";
+			configuration.Properties[Environment.CacheProvider] = typeof(HashtableCacheProvider).AssemblyQualifiedName;
+			configuration.Properties[Environment.UseQueryCache] = "true";
 		}
 
 		[Test]
@@ -35,7 +32,18 @@ public void InvalidatesEntities()
 				x => x.UpdateTimestampsCache,
 				cache);
 
-			var items = new List<Item>();
+			//"Received" assertions can not be used since the collection is reused and cleared between calls.
+			//The received args are cloned and stored
+			var preInvalidations = new List<IReadOnlyCollection<string>>();
+			var invalidations = new List<IReadOnlyCollection<string>>();
+
+			cache
+				.When(x=>x.PreInvalidate(Arg.Any<IReadOnlyCollection<string>>()))
+				.Do(x=>preInvalidations.Add(((IReadOnlyCollection<string>) x[0]).ToList()));
+			cache
+				.When(x => x.Invalidate(Arg.Any<IReadOnlyCollection<string>>()))
+				.Do(x => invalidations.Add(((IReadOnlyCollection<string>) x[0]).ToList()));
+
 			using (ISession session = OpenSession())
 			{
 				using (ITransaction tx = session.BeginTransaction())
@@ -73,8 +81,17 @@ public void InvalidatesEntities()
 			}
 
 			//Should receive one preinvalidation and one invalidation per commit
-			cache.Received(3).PreInvalidate(Arg.Is<IReadOnlyCollection<object>>(x => x.Count == 1 && (string) x.First() == "Item"));
-			cache.Received(3).Invalidate(Arg.Is<IReadOnlyCollection<object>>(x => x.Count == 1 && (string) x.First() == "Item"));
+			Assert.That(preInvalidations.Count,Is.EqualTo(3));
+			Assert.That(preInvalidations.All(x => x.Count == 1 && x.First() == "Item"), Is.True);
+
+			Assert.That(invalidations.Count, Is.EqualTo(3));
+			Assert.That(invalidations.All(x => x.Count == 1 && x.First() == "Item"), Is.True);
+
+		}
+
+		private bool IsRight(HashSet<string> x)
+		{
+			return x.Count == 1 && x.First() == "Item";
 		}
 
 		public void CleanUp()

src/NHibernate/Cache/UpdateTimestampsCache.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Runtime.CompilerServices;
 
 using NHibernate.Cfg;
@@ -33,13 +34,15 @@ public UpdateTimestampsCache(Settings settings, IDictionary<string, string> prop
 			updateTimestamps = settings.CacheProvider.BuildCache(regionName, props);
 		}
 
+		//TODO: Make obsolete
 		public void PreInvalidate(object[] spaces)
 		{
-			PreInvalidate((IReadOnlyList<object>) spaces);
+			//Only for backwards compatibility.
+			PreInvalidate(spaces.OfType<string>().ToList());
 		}
 
 		[MethodImpl(MethodImplOptions.Synchronized)]
-		public virtual void PreInvalidate(IReadOnlyCollection<object> spaces)
+		public virtual void PreInvalidate(IReadOnlyCollection<string> spaces)
 		{
 			//TODO: to handle concurrent writes correctly, this should return a Lock to the client
 			long ts = updateTimestamps.NextTimestamp() + updateTimestamps.Timeout;
@@ -51,14 +54,15 @@ public virtual void PreInvalidate(IReadOnlyCollection<object> spaces)
 			//TODO: return new Lock(ts);
 		}
 
-		/// <summary></summary>
+		//TODO: Make obsolete
 		public void Invalidate(object[] spaces)
 		{
-			Invalidate((IReadOnlyList<object>) spaces);
+			//Only for backwards compatibility.
+			Invalidate(spaces.OfType<string>().ToList());
 		}
 
 		[MethodImpl(MethodImplOptions.Synchronized)]
-		public virtual void Invalidate(IReadOnlyCollection<object> spaces)
+		public virtual void Invalidate(IReadOnlyCollection<string> spaces)
 		{
 			//TODO: to handle concurrent writes correctly, the client should pass in a Lock
 			long ts = updateTimestamps.NextTimestamp();