public void WhenArrayThenNoMatch() { var member = ForClass <MyClass> .Property(x => x.Array); var pattern = new UseBagWhenGenericListPattern(); pattern.Match(member).Should().Be.False(); }
public void WhenListThenNoMatch() { var member = ForClass <MyClass> .Property(x => x.List); var pattern = new UseSetWhenGenericCollectionPattern(); pattern.Match(member).Should().Be.False(); }
public void AssignPropertyReference() { var hbm = new HbmKey(); var km = new KeyMapper(typeof(Animal), hbm); km.PropertyRef(ForClass <Animal> .Property(x => x.Name)); hbm.propertyref.Should().Be("Name"); }
public void WhenListThenMatch() { var member = ForClass <MyClass> .Property(x => x.List); var pattern = new UseBagWhenGenericListPattern(); pattern.Match(member).Should().Be.True(); }
public void WhenGenericCollectionThenMatch() { var member = ForClass <MyClass> .Property(x => x.Collection); var pattern = new UseSetWhenGenericCollectionPattern(); pattern.Match(member).Should().Be.True(); }
public void WhenRelationIsElementsInsideComponentThenNoMatch() { var orm = new Mock <IDomainInspector>(); var pattern = new CollectionOfComponentsKeyColumnApplier(orm.Object); var path = new PropertyPath(new PropertyPath(null, ForClass <MyClass> .Property(p => p.Components)), ForClass <MyComponent> .Property(p => p.Elements)); pattern.Match(path).Should().Be.False(); }
public void WhenNoGenericCollectionThenNoMatch() { var orm = new Mock <IDomainInspector>(); var pattern = new CollectionOfComponentsKeyColumnApplier(orm.Object); var path = new PropertyPath(null, ForClass <MyClass> .Property(p => p.Something)); pattern.Match(path).Should().Be.False(); }
public void WhenCollectionOfComponentsThenNoMatch() { var orm = GetDomainInspectorMock(); var pattern = new UnidirectionalOneToManyMemberPattern(orm.Object); pattern.Match(ForClass <MyClass> .Property(mc => mc.Components)).Should().Be.False(); }
public void WhenDictionaryUnidirectionalThenMatch() { var orm = GetDomainInspectorMock(); var pattern = new UnidirectionalOneToManyMemberPattern(orm.Object); pattern.Match(ForClass <MyClass> .Property(mc => mc.DicRelateds)).Should().Be.True(); }
public void WhenRelationNotDeclaredAsManyToManyUnidirectionalThenNoMatch() { var orm = new Mock <IDomainInspector>(); var pattern = new ManyToManyPattern(orm.Object); pattern.Match(ForClass <MyClass> .Property(x => x.MyOtherClasses)).Should().Be.False(); pattern.Match(ForClass <MyClass> .Property(x => x.MyBidirects)).Should().Be.False(); pattern.Match(ForClass <MyBidirect> .Property(x => x.MyClasses)).Should().Be.False(); }
public void WhenNullableEnumAlwaysApplyColumnType() { var propertyMapper = new Mock <IElementMapper>(); var applier = new EnumElementAsStringApplier(); applier.Apply(ForClass <MyClass> .Property(x => x.MyEnumNullable), propertyMapper.Object); propertyMapper.Verify(x => x.Type(It.Is <Type>(t => t == typeof(EnumStringType <MyEnum?>)), It.Is <object>(p => p == null))); }
public void WhenPreviousLevelIsCollectionThenDoesNotMatch() { var lelev0 = new PropertyPath(null, ForClass <MyClassWithComponent> .Property(x => x.Component1)); var lelev1 = new PropertyPath(lelev0, ForClass <MyComponent> .Property(x => x.Collection)); var lelev2 = new PropertyPath(lelev1, ForClass <MyClass> .Property(x => x.Fake1)); var pattern = new ComponentMemberDeepPathPattern(); pattern.Match(lelev2).Should().Be.False(); }
public void AlwaysApplyCurrencyType() { var propertyMapper = new Mock <IPropertyMapper>(); var applier = new UseCurrencyForDecimalApplier(); applier.Apply(ForClass <MyClass> .Property(x => x.Price), propertyMapper.Object); propertyMapper.Verify(x => x.Type(It.Is <IType>(t => t == NHibernateUtil.Currency))); }
public void CanSetLazy() { var mapdoc = new HbmMapping(); var component = new HbmComponent(); var mapper = new ComponentMapper(component, typeof(Name), ForClass <Person> .Property(p => p.Name), mapdoc); mapper.Lazy(true); component.lazy.Should().Be.True(); }
public void WhenCollectionOfComponentsThenNoMatch() { var orm = GetDomainInspectorMock(); var pattern = new UnidirectionalOneToManyMultipleCollectionsKeyColumnApplier(orm.Object); var property = new PropertyPath(null, ForClass <MyClass> .Property(mc => mc.Components)); pattern.Match(property).Should().Be.False(); }
public void AlwaysApplyColumnType() { var propertyMapper = new Mock <IPropertyMapper>(); var applier = new MsSQL2008DateTimeApplier(); applier.Apply(ForClass <MyClass> .Property(x => x.CreatedAt), propertyMapper.Object); propertyMapper.Verify(x => x.Type(It.Is <IType>(t => t == NHibernateUtil.DateTime2))); }
public void MatchAnyValidPropertyPath() { var applier = new ListIndexAsPropertyPosColumnNameApplier(); applier.Match(null).Should().Be.False(); var ppath = new PropertyPath(null, ForClass <MyClass> .Property(mc => mc.Numbers)); applier.Match(ppath).Should().Be.True(); }
public void CanSetInsert() { var mapdoc = new HbmMapping(); var component = new HbmComponent(); var mapper = new ComponentMapper(component, typeof(Name), ForClass <Person> .Property(p => p.Name), mapdoc); mapper.Insert(false); component.insert.Should().Be.False(); }
public void CanSetParentAccessor() { var mapdoc = new HbmMapping(); var component = new HbmComponent(); var mapper = new ComponentMapper(component, typeof(Name), ForClass <Person> .Property(p => p.Name), mapdoc); mapper.Parent(typeof(Address).GetProperty("Parent"), pm => pm.Access(Accessor.Field)); component.Parent.access.Should().Contain("field"); }
public void CanSetOptimisticLock() { var mapdoc = new HbmMapping(); var component = new HbmComponent(); var mapper = new ComponentMapper(component, typeof(Name), ForClass <Person> .Property(p => p.Name), mapdoc); mapper.OptimisticLock(false); component.optimisticlock.Should().Be.False(); }
public void WhenRelationIsNotOneToManyThenNoMatch() { var orm = new Mock <IDomainInspector>(); var pattern = new OneToManyPattern(orm.Object); orm.Setup(x => x.IsOneToMany(It.Is <Type>(t => t == typeof(MyClass)), It.Is <Type>(t => t == typeof(Element)))).Returns(false); pattern.Match(ForClass <MyClass> .Property(p => p.Elements)).Should().Be.False(); }
public void WhenComponentsCollectionInsideComponentThenMatch() { var orm = new Mock <IDomainInspector>(); var pattern = new CollectionOfComponentsPattern(orm.Object); orm.Setup(x => x.IsComponent(typeof(MyComponent))).Returns(true); pattern.Match(ForClass <MyComponent> .Property(p => p.Components)).Should().Be.True(); }
public void WhenVersionPropertyDefinedOnInterfaceThenRecognizeItOnConcreteClass() { var orm = new ObjectRelationalMapper(); orm.TablePerClass <MyVersionedEntityOnInterface>(); orm.VersionProperty <IVersionedEntity>(versionedEntity => versionedEntity.Version); orm.IsVersion(ForClass <MyVersionedEntityOnInterface> .Property(e => e.Version)).Should().Be.True(); }
public void WhenRegisterExclusionPropertyOnInterfaceThenShouldExcludePropertyOfConcreteImpl() { var orm = new ObjectRelationalMapper(); orm.TablePerClass <Person>(); orm.ExcludeProperty <IEntity>(p => p.Something); orm.IsPersistentProperty(ForClass <Person> .Property(p => p.Something)).Should().Be.False(); }
public void WhenDictionaryUnidirectionalThenMatch() { var orm = GetDomainInspectorMock(); var pattern = new UnidirectionalOneToManyMultipleCollectionsKeyColumnApplier(orm.Object); var property = new PropertyPath(null, ForClass <MyClass> .Property(mc => mc.DicRelateds)); pattern.Match(property).Should().Be.True(); }
public void WhenRegisterCollectionToCollectionThenFindRelation() { var orm = new ObjectRelationalMapper(); orm.Bidirectional <B, A>(b => b.Generic, a => a.Bag); orm.GetBidirectionalMember(typeof(A), ForClass <A> .Property(x => x.Bag), typeof(B)).Should().Be(ForClass <B> .Property(x => x.Generic)); orm.GetBidirectionalMember(typeof(B), ForClass <B> .Property(x => x.Generic), typeof(A)).Should().Be(ForClass <A> .Property(x => x.Bag)); }
public void WhenRegisterPersistentPropertyOnInterfaceThenShouldRecognizePropertyOfConcreteImpl() { var orm = new ObjectRelationalMapper(); orm.TablePerClass <Person>(); orm.PersistentProperty <IEntity>(p => p.IsValid); orm.IsPersistentProperty(ForClass <Person> .Property(p => p.IsValid)).Should().Be.True(); }
public void WhenSingleUsageThenNoMatch() { var orm = GetDomainInspectorMockForBaseTests(); var applier = new UnidirectionalOneToManyMultipleCollectionsKeyColumnApplier(orm.Object); var property = new PropertyPath(null, ForClass <MySingleUsage> .Property(x => x.CurrentPositions)); applier.Match(property).Should().Be.False(); }
public void WhenRelationIsOneToManyInsideComponentThenNoMatch() { var orm = new Mock <IDomainInspector>(); var pattern = new CollectionOfElementsOnlyPattern(orm.Object); orm.Setup(x => x.IsOneToMany(It.Is <Type>(t => t == typeof(MyComponent)), It.Is <Type>(t => t == typeof(MyRelated)))).Returns(true); pattern.Match(ForClass <MyComponent> .Property(p => p.Relateds)).Should().Be.False(); }
public void WhenRelationIsForMapKeyThenMatch() { var orm = new Mock <IDomainInspector>(); var pattern = new CollectionOfElementsPattern(orm.Object); orm.Setup(x => x.IsManyToMany(It.Is <Type>(t => t == typeof(MyClass)), It.Is <Type>(t => t == typeof(MyRelated)))).Returns(true); pattern.Match(ForClass <MyClass> .Property(p => p.MapRelationOnKey)).Should().Be.True(); }