public void EntityKey_Creation() { // Test one of the generic Create overloads (that doesn't box // the key values) object key = EntityKey.Create(5, 2.34M, "test", "hello world"); string formattedKey = key.ToString(); object[] keyValues = new object[] { 5, 2.34M, "test", "hello world" }; string expectedKey = "{" + string.Join(",", keyValues) + "}"; Assert.AreEqual(expectedKey, formattedKey); // pass the same set into the params version and verify the keys are equal object key2 = EntityKey.Create(keyValues); Assert.AreSame(key.GetType(), key2.GetType()); Assert.AreEqual(key, key2); Assert.AreEqual(key.GetHashCode(), key2.GetHashCode()); // Test boxing version for N key values key = EntityKey.Create(5, "hello", 3, 4, 5, "test", 2132, '?'); formattedKey = key.ToString(); Assert.AreEqual("{5,hello,3,4,5,test,2132,?}", formattedKey); // pass the same set of values into the params version and verify the keys are equal key2 = EntityKey.Create(new object[] { 5, "hello", 3, 4, 5, "test", 2132, '?' }); Assert.AreEqual(key, key2); Assert.AreEqual(key.GetHashCode(), key2.GetHashCode()); }
public void should_refresh_cache_on_update() { var zh_CN = CultureInfo.GetCultureInfo("zh-CN"); var translationsInDb = new [] { CreateBrandTranslation(1, zh_CN, "Translated Brand1") }; var underlyingStoreMock = new Mock <ITranslationStore>(); underlyingStoreMock.Setup(it => it.Find(zh_CN, new[] { EntityKey.Create <Brand>(1) })) .Returns(translationsInDb); underlyingStoreMock.Setup(it => it.AddOrUpdate(zh_CN, EntityKey.Create <Brand>(1), It.IsAny <IEnumerable <PropertyTranslation> >())) .Callback(() => { translationsInDb[0].PropertyTranslations[0].TranslatedText = "Translated Brand1 (Update)"; }); var store = new CachedTranslactionStore(underlyingStoreMock.Object, new [] { typeof(Brand) }); var translation = store.Find(zh_CN, EntityKey.Create <Brand>(1)); Assert.Equal("Translated Brand1", translation.PropertyTranslations[0].TranslatedText); store.AddOrUpdate(zh_CN, EntityKey.Create <Brand>(1), new List <PropertyTranslation> { new PropertyTranslation("Name", "Brand1", "Translated Brand1 (Update)") }); Assert.Equal("Translated Brand1 (Update)", translationsInDb[0].PropertyTranslations[0].TranslatedText); translation = store.Find(zh_CN, EntityKey.Create <Brand>(1)); Assert.Equal("Translated Brand1 (Update)", translation.PropertyTranslations[0].TranslatedText); }
private EntityTransaltion CreateBrandTranslation(int brandId, CultureInfo culture, string translatedName) { return(new EntityTransaltion(culture.Name, EntityKey.Create <Brand>(brandId), new List <PropertyTranslation> { new PropertyTranslation("Name", "Apple", translatedName) })); }
public void EntityKey_NullValues() { string expectedMsg = new ArgumentNullException("value", Resource.EntityKey_CannotBeNull).Message; ArgumentNullException expectedException = null; try { EntityKey.Create(new object[] { 5, null, "test" }); } catch (ArgumentNullException e) { expectedException = e; } Assert.AreEqual(expectedMsg, expectedException.Message); expectedException = null; try { EntityKey.Create <int, string>(5, null); } catch (ArgumentNullException e) { expectedException = e; } Assert.AreEqual(expectedMsg, expectedException.Message); expectedException = null; }
public void EntityKey_TestHashCodeValues() { Guid g = Guid.NewGuid(); object[] keyValues = new object[] { 123, 34.5M, "hello", new DateTime(234234), g, false, '?' }; object key = EntityKey.Create(keyValues); int hashCode = key.GetHashCode(); int expectedHashCode = 0; foreach (object keyValue in keyValues) { expectedHashCode ^= keyValue.GetHashCode(); } Assert.AreEqual(expectedHashCode, hashCode); // test the non-boxed version and verify we get the same hashcode key = EntityKey.Create(123, 34.5M, "hello", new DateTime(234234), g, false, '?'); hashCode = key.GetHashCode(); Assert.AreEqual(expectedHashCode, hashCode); // compute directly without boxing and verify equal int directlyComputed = ((int)123).GetHashCode() ^ ((decimal)34.5M).GetHashCode() ^ "hello".GetHashCode() ^ new DateTime(234234).GetHashCode() ^ g.GetHashCode() ^ false.GetHashCode() ^ '?'.GetHashCode(); Assert.AreEqual(directlyComputed, key.GetHashCode()); }
public void can_cache_not_translated_items() { var zh_CN = CultureInfo.GetCultureInfo("zh-CN"); var brandKeys = new[] { EntityKey.Create <Brand>(1), EntityKey.Create <Brand>(2) }; var brandTranslations = new[] { CreateBrandTranslation(1, zh_CN, "Apple China"), null }; var underlyingStoreMock = new Mock <ITranslationStore>(); underlyingStoreMock.Setup(it => it.Find(zh_CN, brandKeys)).Returns(brandTranslations); var store = new CachedTranslactionStore(underlyingStoreMock.Object, new[] { typeof(Brand) }); var actualResult = store.Find(zh_CN, brandKeys); Assert.NotNull(actualResult[0]); Assert.Equal("Apple China", actualResult[0].PropertyTranslations[0].TranslatedText); Assert.Null(actualResult[1]); actualResult = store.Find(zh_CN, brandKeys); Assert.NotNull(actualResult[0]); Assert.Equal("Apple China", actualResult[0].PropertyTranslations[0].TranslatedText); Assert.Null(actualResult[1]); underlyingStoreMock.Verify(it => it.Find(zh_CN, brandKeys), Times.Once()); }
public void should_cache_by_culture() { var zh_CN = CultureInfo.GetCultureInfo("zh-CN"); var nl_NL = CultureInfo.GetCultureInfo("nl-NL"); var brandKey = EntityKey.Create <Brand>(15); var cnTranslation = CreateBrandTranslation(15, zh_CN, "Apple China"); var nlTranslation = CreateBrandTranslation(15, nl_NL, "Apple Dutch"); var underlyingStoreMock = new Mock <ITranslationStore>(); underlyingStoreMock.Setup(it => it.Find(zh_CN, new[] { brandKey })) .Returns(new[] { cnTranslation }); underlyingStoreMock.Setup(it => it.Find(nl_NL, new[] { brandKey })) .Returns(new[] { nlTranslation }); var store = new CachedTranslactionStore(underlyingStoreMock.Object, new[] { typeof(Brand) }); var translation = store.Find(zh_CN, brandKey); Assert.Equal("Apple China", translation.PropertyTranslations[0].TranslatedText); translation = store.Find(nl_NL, brandKey); Assert.Equal("Apple Dutch", translation.PropertyTranslations[0].TranslatedText); }
//Helper method that can be used to create composite primary keys /// <summary>Creates a primary key object for an entity identified by type. Use it for entity types with composite primary key, to create a key instance from /// column values. The created key may be used in session.GetEntity() method as primary key parameter. </summary> /// <typeparam name="TEntity">Entity type.</typeparam> /// <param name="session">The entity session.</param> /// <param name="values">Value(s) of the primary key columns.</param> /// <returns>A primary key object.</returns> public static object CreatePrimaryKey <TEntity>(this IEntitySession session, params object[] values) { Util.CheckParam(values, "values"); var entInfo = session.Context.App.Model.GetEntityInfo(typeof(TEntity), throwIfNotFound: true); var pk = EntityKey.Create(entInfo.PrimaryKey, values); return(pk); }
public override object GetIdentity() { if (this._stationCode == null) { return(null); } return(EntityKey.Create <string, DateTime>(this._stationCode, this._timePoint)); }
/// <summary> /// Computes a value from the key fields that uniquely identifies this entity instance. /// </summary> /// <returns>An object instance that uniquely identifies this entity instance.</returns> public override object GetIdentity() { if (((this._email == null) || (this._userName == null))) { return(null); } return(EntityKey.Create(this._email, this._userName)); }
/// <summary> /// Computes a value from the key fields that uniquely identifies this entity instance. /// </summary> /// <returns>An object instance that uniquely identifies this entity instance.</returns> public override object GetIdentity() { if (((((this._email == null) || (this._firstName == null)) || (this._lastName == null)) || (this._userName == null))) { return(null); } return(EntityKey.Create(this._country, this._dateOfBirth, this._email, this._firstName, this._gender, this._lastName, this._userName)); }
public override object GetIdentity() { if (this._stationCode != null) { goto Label_000A; } return(null); Label_000A: return(EntityKey.Create <string, DateTime>(this._stationCode, this._timePoint)); }
public static EntityKey CreatePrimaryKeyInstance(this EntityInfo entity, object primaryKeyValue) { var pkType = primaryKeyValue.GetType(); switch (primaryKeyValue) { case EntityKey key: return(key); case object[] arr: return(EntityKey.Create(entity.PrimaryKey, arr)); default: return(EntityKey.Create(entity.PrimaryKey, new object[] { primaryKeyValue })); } }
public void should_fetch_from_cache_on_second_find() { var zh_CN = CultureInfo.GetCultureInfo("zh-CN"); var underlyingStoreMock = new Mock <ITranslationStore>(); underlyingStoreMock.Setup(it => it.Find(It.IsAny <CultureInfo>(), It.IsAny <EntityKey[]>())) .Returns(new[] { CreateBrandTranslation(1, zh_CN, "Apple Translated") }); var store = new CachedTranslactionStore(underlyingStoreMock.Object, new[] { typeof(Brand) }); var translations = store.Find(zh_CN, new[] { EntityKey.Create <Brand>(1) }); underlyingStoreMock.Verify(it => it.Find(zh_CN, new[] { EntityKey.Create <Brand>(1) }), Times.Once()); translations = store.Find(zh_CN, new[] { EntityKey.Create <Brand>(1) }); underlyingStoreMock.Verify(it => it.Find(zh_CN, new[] { EntityKey.Create <Brand>(1) }), Times.Once()); }
public void should_only_cache_types_configured_to_be_cached() { var zh_CN = CultureInfo.GetCultureInfo("zh-CN"); var underlyingStoreMock = new Mock <ITranslationStore>(); underlyingStoreMock.Setup(it => it.Find(zh_CN, new[] { EntityKey.Create <Product>(1) })) .Returns(new[] { new EntityTransaltion("zh-CN", EntityKey.Create <Product>(1), new List <PropertyTranslation> { new PropertyTranslation("Name", "Product1", "Translated Product1") }) }); var store = new CachedTranslactionStore(underlyingStoreMock.Object, new[] { typeof(Brand) }); store.Find(zh_CN, new[] { EntityKey.Create <Product>(1) }); store.Find(zh_CN, new[] { EntityKey.Create <Product>(1) }); underlyingStoreMock.Verify(it => it.Find(CultureInfo.GetCultureInfo("zh-CN"), new[] { EntityKey.Create <Product>(1) }), Times.Exactly(2)); }
public void should_combine_result_of_cached_and_uncached() { var zh_CN = CultureInfo.GetCultureInfo("zh-CN"); var allTranslations = new[] { CreateBrandTranslation(1, zh_CN, "Apple Translated"), CreateBrandTranslation(2, zh_CN, "Dell Translated"), CreateBrandTranslation(3, zh_CN, "Lenovo Translated") }; var underlyingStoreMock = new Mock <ITranslationStore>(); underlyingStoreMock.Setup(it => it.Find(zh_CN, It.IsAny <EntityKey[]>())) .Returns <CultureInfo, EntityKey[]>((culture, keys) => { var result = new List <EntityTransaltion>(); foreach (var key in keys) { result.Add(allTranslations.First(it => it.EntityKey.Equals(key))); } return(result.ToArray()); }); var store = new CachedTranslactionStore(underlyingStoreMock.Object, new[] { typeof(Brand) }); var translations = store.Find(zh_CN, EntityKey.Create <Brand>(1), EntityKey.Create <Brand>(2)); Assert.NotNull(translations[0]); Assert.NotNull(translations[1]); Assert.Equal("Apple Translated", translations[0].PropertyTranslations[0].TranslatedText); Assert.Equal("Dell Translated", translations[1].PropertyTranslations[0].TranslatedText); translations = store.Find(zh_CN, EntityKey.Create <Brand>(1), EntityKey.Create <Brand>(3)); Assert.NotNull(translations[0]); Assert.NotNull(translations[1]); Assert.Equal("Apple Translated", translations[0].PropertyTranslations[0].TranslatedText); Assert.Equal("Lenovo Translated", translations[1].PropertyTranslations[0].TranslatedText); }
public void should_fetch_from_underlying_store_if_not_cached() { var zh_CN = CultureInfo.GetCultureInfo("zh-CN"); var underlyingStoreMock = new Mock <ITranslationStore>(); underlyingStoreMock.Setup(it => it.Find(It.IsAny <CultureInfo>(), It.IsAny <EntityKey[]>())) .Returns(new[] { CreateBrandTranslation(1, zh_CN, "Apple Translated") }); var store = new CachedTranslactionStore(underlyingStoreMock.Object, new [] { typeof(Brand) }); var translations = store.Find(zh_CN, new[] { EntityKey.Create <Brand>(1) }); Assert.Equal(1, translations.Length); Assert.NotNull(translations[0]); Assert.Equal("Apple Translated", translations[0].PropertyTranslations[0].TranslatedText); underlyingStoreMock.Verify(it => it.Find(zh_CN, new[] { EntityKey.Create <Brand>(1) }), Times.Once()); translations = store.Find(zh_CN, new[] { EntityKey.Create <Brand>(2) }); underlyingStoreMock.Verify(it => it.Find(zh_CN, new[] { EntityKey.Create <Brand>(1) }), Times.Once()); underlyingStoreMock.Verify(it => it.Find(zh_CN, new[] { EntityKey.Create <Brand>(2) }), Times.Once()); }
public override object GetIdentity() { return(EntityKey.Create(ID1, ID2)); }