Skip to content

Commit 46719bf

Browse files
maca88maca88
committed
Added serialization tests for NHibernate types
1 parent 19d59ba commit 46719bf

File tree

3 files changed

+480
-0
lines changed

3 files changed

+480
-0
lines changed

‎AsyncGenerator.yml

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -703,6 +703,8 @@
703703
withoutCancellationToken:
704704
- hasAttributeName: TestAttribute
705705
- hasAttributeName: TheoryAttribute
706+
ignoreSearchForAsyncCounterparts:
707+
- name: Disassemble
706708
scanMethodBody: true
707709
searchAsyncCounterpartsInInheritedTypes: true
708710
scanForMissingAsyncMembers:

‎StackExRedis/NHibernate.Caches.StackExRedis.Tests/Async/RedisCacheFixture.cs

Lines changed: 236 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -10,19 +10,255 @@
1010

1111
using System;
1212
using System.Collections.Generic;
13+
using System.Globalization;
1314
using System.Linq;
15+
using System.Reflection;
1416
using System.Text;
1517
using System.Threading;
1618
using System.Threading.Tasks;
19+
using System.Xml;
20+
using System.Xml.Linq;
1721
using NHibernate.Cache;
22+
using NHibernate.Cache.Entry;
1823
using NHibernate.Caches.Common.Tests;
24+
using NHibernate.Collection;
25+
using NHibernate.Engine;
26+
using NHibernate.Persister.Entity;
27+
using NHibernate.Type;
28+
using NSubstitute;
1929
using NUnit.Framework;
2030

2131
namespace NHibernate.Caches.StackExRedis.Tests
2232
{
2333
public abstract partial class RedisCacheFixture : CacheFixture
2434
{
2535

36+
[Test]
37+
public async Task TestNHibernateAnyTypeSerializationAsync()
38+
{
39+
var objectTypeCacheEntryType = typeof(AnyType.ObjectTypeCacheEntry);
40+
var entityNameField = objectTypeCacheEntryType.GetField("entityName", BindingFlags.Instance | BindingFlags.NonPublic);
41+
Assert.That(entityNameField, Is.Not.Null, "field entityName in NHibernate.Type.AnyType.ObjectTypeCacheEntry was not found");
42+
var idField = objectTypeCacheEntryType.GetField("id", BindingFlags.Instance | BindingFlags.NonPublic);
43+
Assert.That(idField, Is.Not.Null, "field id in NHibernate.Type.AnyType.ObjectTypeCacheEntry was not found");
44+
45+
var entityName = nameof(MyEntity);
46+
var propertyValues = new Dictionary<IType, object>
47+
{
48+
{NHibernateUtil.Object, new MyEntity{Id = 2}}
49+
};
50+
51+
var sfImpl = Substitute.For<ISessionFactoryImplementor>();
52+
var sessionImpl = Substitute.For<ISessionImplementor>();
53+
sessionImpl.BestGuessEntityName(Arg.Any<object>()).Returns(o => o[0].GetType().Name);
54+
sessionImpl.GetContextEntityIdentifier(Arg.Is<object>(o => o is MyEntity)).Returns(o => ((MyEntity) o[0]).Id);
55+
var entityPersister = Substitute.For<IEntityPersister>();
56+
entityPersister.EntityName.Returns(entityName);
57+
entityPersister.IsLazyPropertiesCacheable.Returns(false);
58+
entityPersister.PropertyTypes.Returns(propertyValues.Keys.ToArray());
59+
60+
var cacheKey = new CacheKey(1, NHibernateUtil.Int32, entityName, sfImpl);
61+
var cacheEntry = new CacheEntry(propertyValues.Values.ToArray(), entityPersister, false, null, sessionImpl, null);
62+
63+
Assert.That(cacheEntry.DisassembledState, Has.Length.EqualTo(1));
64+
var anyObject = cacheEntry.DisassembledState[0];
65+
Assert.That(anyObject, Is.TypeOf(objectTypeCacheEntryType));
66+
Assert.That(entityNameField.GetValue(anyObject), Is.EqualTo(nameof(MyEntity)));
67+
Assert.That(idField.GetValue(anyObject), Is.EqualTo(2));
68+
69+
var cache = GetDefaultCache();
70+
await (cache.PutAsync(cacheKey, cacheEntry, CancellationToken.None));
71+
var value = await (cache.GetAsync(cacheKey, CancellationToken.None));
72+
73+
Assert.That(value, Is.TypeOf<CacheEntry>());
74+
var retrievedCacheEntry = (CacheEntry) value;
75+
Assert.That(retrievedCacheEntry.DisassembledState, Has.Length.EqualTo(1));
76+
var retrievedAnyObject = retrievedCacheEntry.DisassembledState[0];
77+
Assert.That(retrievedAnyObject, Is.TypeOf(objectTypeCacheEntryType));
78+
Assert.That(entityNameField.GetValue(retrievedAnyObject), Is.EqualTo(nameof(MyEntity)),
79+
"entityName is different from the original AnyType.ObjectTypeCacheEntry");
80+
Assert.That(idField.GetValue(retrievedAnyObject), Is.EqualTo(2),
81+
"id is different from the original AnyType.ObjectTypeCacheEntry");
82+
}
83+
84+
[Test]
85+
public async Task TestNHibernateStandardTypesSerializationAsync()
86+
{
87+
var entityName = nameof(MyEntity);
88+
var xmlDoc = new XmlDocument();
89+
xmlDoc.LoadXml("<Root>XmlDoc</Root>");
90+
var propertyValues = new Dictionary<IType, object>
91+
{
92+
{NHibernateUtil.AnsiString, "test"},
93+
{NHibernateUtil.Binary, new byte[] {1, 2, 3, 4}},
94+
{NHibernateUtil.BinaryBlob, new byte[] {1, 2, 3, 4}},
95+
{NHibernateUtil.Boolean, true},
96+
{NHibernateUtil.Byte, (byte) 1},
97+
{NHibernateUtil.Character, 'a'},
98+
{NHibernateUtil.CultureInfo, CultureInfo.CurrentCulture},
99+
{NHibernateUtil.DateTime, DateTime.Now},
100+
{NHibernateUtil.DateTimeNoMs, DateTime.Now},
101+
{NHibernateUtil.LocalDateTime, DateTime.Now},
102+
{NHibernateUtil.UtcDateTime, DateTime.UtcNow},
103+
{NHibernateUtil.LocalDateTimeNoMs, DateTime.Now},
104+
{NHibernateUtil.UtcDateTimeNoMs, DateTime.UtcNow},
105+
{NHibernateUtil.DateTimeOffset, DateTimeOffset.Now},
106+
{NHibernateUtil.Date, DateTime.Today},
107+
{NHibernateUtil.Decimal, 2.5m},
108+
{NHibernateUtil.Double, 2.5d},
109+
{NHibernateUtil.Currency, 2.5m},
110+
{NHibernateUtil.Guid, Guid.NewGuid()},
111+
{NHibernateUtil.Int16, (short) 1},
112+
{NHibernateUtil.Int32, 3},
113+
{NHibernateUtil.Int64, 3L},
114+
{NHibernateUtil.SByte, (sbyte) 1},
115+
{NHibernateUtil.UInt16, (ushort) 1},
116+
{NHibernateUtil.UInt32, (uint) 1},
117+
{NHibernateUtil.UInt64, (ulong) 1},
118+
{NHibernateUtil.Single, 1.1f},
119+
{NHibernateUtil.String, "test"},
120+
{NHibernateUtil.StringClob, "test"},
121+
{NHibernateUtil.Time, DateTime.Now},
122+
{NHibernateUtil.Ticks, DateTime.Now},
123+
{NHibernateUtil.TimeAsTimeSpan, TimeSpan.FromMilliseconds(15)},
124+
{NHibernateUtil.TimeSpan, TimeSpan.FromMilliseconds(1234)},
125+
{NHibernateUtil.DbTimestamp, DateTime.Now},
126+
{NHibernateUtil.TrueFalse, false},
127+
{NHibernateUtil.YesNo, true},
128+
{NHibernateUtil.Class, typeof(IType)},
129+
{NHibernateUtil.ClassMetaType, entityName},
130+
{NHibernateUtil.Serializable, new MyEntity {Id = 1}},
131+
{NHibernateUtil.AnsiChar, 'a'},
132+
{NHibernateUtil.XmlDoc, xmlDoc},
133+
{NHibernateUtil.XDoc, XDocument.Parse("<Root>XDoc</Root>")},
134+
{NHibernateUtil.Uri, new Uri("http://test.com")}
135+
};
136+
137+
var sfImpl = Substitute.For<ISessionFactoryImplementor>();
138+
var sessionImpl = Substitute.For<ISessionImplementor>();
139+
var entityPersister = Substitute.For<IEntityPersister>();
140+
entityPersister.EntityName.Returns(entityName);
141+
entityPersister.IsLazyPropertiesCacheable.Returns(false);
142+
entityPersister.PropertyTypes.Returns(propertyValues.Keys.ToArray());
143+
144+
var cacheKey = new CacheKey(1, NHibernateUtil.Int32, entityName, sfImpl);
145+
var cacheEntry = new CacheEntry(propertyValues.Values.ToArray(), entityPersister, false, null, sessionImpl, null);
146+
147+
var cache = GetDefaultCache();
148+
await (cache.PutAsync(cacheKey, cacheEntry, CancellationToken.None));
149+
var value = await (cache.GetAsync(cacheKey, CancellationToken.None));
150+
151+
Assert.That(value, Is.TypeOf<CacheEntry>());
152+
var retrievedCacheEntry = (CacheEntry) value;
153+
Assert.That(retrievedCacheEntry.DisassembledState, Is.EquivalentTo(cacheEntry.DisassembledState),
154+
"DisassembledState is different from the original CacheEntry");
155+
}
156+
157+
[Test]
158+
public async Task TestNHibernateCacheEntrySerializationAsync()
159+
{
160+
var entityName = nameof(MyEntity);
161+
var propertyValues = new Dictionary<IType, object>
162+
{
163+
{NHibernateUtil.String, "test"}
164+
};
165+
166+
var sfImpl = Substitute.For<ISessionFactoryImplementor>();
167+
var sessionImpl = Substitute.For<ISessionImplementor>();
168+
var entityPersister = Substitute.For<IEntityPersister>();
169+
entityPersister.EntityName.Returns(entityName);
170+
entityPersister.IsLazyPropertiesCacheable.Returns(false);
171+
entityPersister.PropertyTypes.Returns(propertyValues.Keys.ToArray());
172+
173+
var cacheKey = new CacheKey(1, NHibernateUtil.Int32, entityName, sfImpl);
174+
var cacheEntry = new CacheEntry(propertyValues.Values.ToArray(), entityPersister, true, 4, sessionImpl, null);
175+
176+
var cache = GetDefaultCache();
177+
await (cache.PutAsync(cacheKey, cacheEntry, CancellationToken.None));
178+
var value = await (cache.GetAsync(cacheKey, CancellationToken.None));
179+
180+
Assert.That(value, Is.TypeOf<CacheEntry>());
181+
var retrievedCacheEntry = (CacheEntry) value;
182+
Assert.That(retrievedCacheEntry.AreLazyPropertiesUnfetched, Is.EqualTo(cacheEntry.AreLazyPropertiesUnfetched),
183+
"AreLazyPropertiesUnfetched is different from the original CacheEntry");
184+
Assert.That(retrievedCacheEntry.DisassembledState, Is.EquivalentTo(cacheEntry.DisassembledState),
185+
"DisassembledState is different from the original CacheEntry");
186+
Assert.That(retrievedCacheEntry.Subclass, Is.EqualTo(cacheEntry.Subclass),
187+
"Subclass is different from the original CacheEntry");
188+
Assert.That(retrievedCacheEntry.Version, Is.EqualTo(cacheEntry.Version),
189+
"Version is different from the original CacheEntry");
190+
}
191+
192+
[Test]
193+
public async Task TestNHibernateCollectionCacheEntrySerializationAsync()
194+
{
195+
var sfImpl = Substitute.For<ISessionFactoryImplementor>();
196+
var collection = Substitute.For<IPersistentCollection>();
197+
collection.Disassemble(null).Returns(o => new object[] {"test"});
198+
199+
var cacheKey = new CacheKey(1, NHibernateUtil.Int32, "MyCollection", sfImpl);
200+
var cacheEntry = new CollectionCacheEntry(collection, null);
201+
Assert.That(cacheEntry.State, Has.Length.EqualTo(1));
202+
203+
var cache = GetDefaultCache();
204+
await (cache.PutAsync(cacheKey, cacheEntry, CancellationToken.None));
205+
var value = await (cache.GetAsync(cacheKey, CancellationToken.None));
206+
207+
Assert.That(value, Is.TypeOf<CollectionCacheEntry>());
208+
var retrievedCacheEntry = (CollectionCacheEntry) value;
209+
Assert.That(retrievedCacheEntry.State, Has.Length.EqualTo(1));
210+
Assert.That(retrievedCacheEntry.State[0], Is.EquivalentTo("test"),
211+
"State is different from the original CollectionCacheEntry");
212+
}
213+
214+
[Test]
215+
public async Task TestNHibernateCacheLockSerializationAsync()
216+
{
217+
var sfImpl = Substitute.For<ISessionFactoryImplementor>();
218+
var cacheKey = new CacheKey(1, NHibernateUtil.Int32, "CacheLock", sfImpl);
219+
var cacheEntry = new CacheLock(1234, 1, 5);
220+
cacheEntry.Lock(123, 2);
221+
222+
var cache = GetDefaultCache();
223+
await (cache.PutAsync(cacheKey, cacheEntry, CancellationToken.None));
224+
var value = await (cache.GetAsync(cacheKey, CancellationToken.None));
225+
226+
Assert.That(value, Is.TypeOf<CacheLock>());
227+
var retrievedCacheEntry = (CacheLock) value;
228+
Assert.That(retrievedCacheEntry.Id, Is.EqualTo(cacheEntry.Id),
229+
"Id is different from the original CacheLock");
230+
Assert.That(retrievedCacheEntry.IsLock, Is.EqualTo(cacheEntry.IsLock),
231+
"IsLock is different from the original CacheLock");
232+
Assert.That(retrievedCacheEntry.WasLockedConcurrently, Is.EqualTo(cacheEntry.WasLockedConcurrently),
233+
"WasLockedConcurrently is different from the original CacheLock");
234+
Assert.That(retrievedCacheEntry.ToString(), Is.EqualTo(cacheEntry.ToString()),
235+
"ToString() is different from the original CacheLock");
236+
}
237+
238+
[Test]
239+
public async Task TestNHibernateCachedItemSerializationAsync()
240+
{
241+
var sfImpl = Substitute.For<ISessionFactoryImplementor>();
242+
var cacheKey = new CacheKey(1, NHibernateUtil.Int32, "CachedItem", sfImpl);
243+
var cacheEntry = new CachedItem("test", 111, 5);
244+
cacheEntry.Lock(123, 2);
245+
246+
var cache = GetDefaultCache();
247+
await (cache.PutAsync(cacheKey, cacheEntry, CancellationToken.None));
248+
var value = await (cache.GetAsync(cacheKey, CancellationToken.None));
249+
250+
Assert.That(value, Is.TypeOf<CachedItem>());
251+
var retrievedCacheEntry = (CachedItem) value;
252+
Assert.That(retrievedCacheEntry.FreshTimestamp, Is.EqualTo(cacheEntry.FreshTimestamp),
253+
"FreshTimestamp is different from the original CachedItem");
254+
Assert.That(retrievedCacheEntry.IsLock, Is.EqualTo(cacheEntry.IsLock),
255+
"IsLock is different from the original CachedItem");
256+
Assert.That(retrievedCacheEntry.Value, Is.EqualTo(cacheEntry.Value),
257+
"Value is different from the original CachedItem");
258+
Assert.That(retrievedCacheEntry.ToString(), Is.EqualTo(cacheEntry.ToString()),
259+
"ToString() is different from the original CachedItem");
260+
}
261+
26262
[Test]
27263
public async Task TestEnvironmentNameAsync()
28264
{

0 commit comments

Comments
 (0)