public void InvokeCustomizerOfDictionaryKeyManyToManyRelation()
{
var propertyPath = new PropertyPath(null, ForClass <MyClass> .Property(x => x.MyDictionary));
var customizersHolder = new CustomizersHolder();
var elementMapper = new Mock <IMapKeyManyToManyMapper>();
customizersHolder.AddCustomizer(propertyPath, (IMapKeyManyToManyMapper x) => x.Column("pizza"));
customizersHolder.InvokeCustomizers(propertyPath, elementMapper.Object);
elementMapper.Verify(x => x.Column(It.Is <string>(v => v == "pizza")), Times.Once());
}
public void CallMapManyToOneMapper()
{
var mapdoc = new HbmMapping();
var component = new HbmCompositeMapKey();
var mapper = new ComponentMapKeyMapper(typeof(ToySkill), component, mapdoc);
var called = false;
mapper.ManyToOne(ForClass <ToySkill> .Property(ts => ts.Skill), x => called = true);
called.Should().Be.True();
}
public void WhenMapDocHasDefaultHasClassName()
{
var entityType = typeof(Person);
var mapdoc = new HbmMapping {
assembly = entityType.Assembly.FullName, @namespace = entityType.Namespace
};
var component = new HbmComponent();
new ComponentMapper(component, typeof(Name), ForClass <Person> .Property(p => p.Name), mapdoc);
component.Class.Should().Be.EqualTo(typeof(Name).Name);
}
public void WhenRelationDeclaredAsManyToManyForDictionaryValueThenMatch()
{
var orm = new Mock <IDomainInspector>();
orm.Setup(x => x.IsManyToMany(It.Is <Type>(t => t == typeof(MyClass)), It.Is <Type>(t => t == typeof(MyBidirect)))).Returns(true);
var path = new PropertyPath(null, ForClass <MyClass> .Property(x => x.MapValue));
var pattern = new ManyToManyInCollectionTableApplier(orm.Object);
pattern.Match(path).Should().Be.False();
}
public void WhenLevel1ThenMatch()
{
var level0 = new PropertyPath(null, ForClass <MyClassWithComponent> .Property(x => x.Component1));
var level1 = new PropertyPath(level0, ForClass <MyComponent> .Property(x => x.MyNested));
var level2 = new PropertyPath(level1, ForClass <MyClass> .Property(x => x.Fake1));
var pattern = new ComponentPropertyColumnNameApplier();
var mapper = new Mock <IPropertyMapper>();
pattern.Apply(level2, mapper.Object);
mapper.Verify(x => x.Column(It.Is <string>(columnName => columnName == "Component1MyNestedFake1")));
}
public void WhenInterfaceOnParentThenMatch()
{
var orm = new ObjectRelationalMapper();
orm.TablePerClass <Parent>();
orm.TablePerClass <Child>();
var pattern = new PolymorphismBidirectionalOneToManyMemberPattern(orm);
pattern.Match(ForClass <Parent> .Property(x => x.Children)).Should().Be.True();
}
public void WhenExplicitlyDeclaredAsBagThenDoesNotUseSet()
{
var mapper = new ObjectRelationalMapper();
mapper.Patterns.Sets.Add(new BagCollectionPattern());
mapper.Bag <A>(a => a.Others);
mapper.IsBag(ForClass <A> .Property(a => a.Others)).Should().Be.True();
mapper.IsSet(ForClass <A> .Property(a => a.NickNames)).Should().Be.True();
mapper.IsSet(ForClass <A> .Property(a => a.Set)).Should().Be.True();
}
public void WhenComponentsCollectionThenMatch()
{
var orm = new Mock <IDomainInspector>();
var pattern = new CollectionOfComponentsKeyColumnApplier(orm.Object);
orm.Setup(x => x.IsComponent(typeof(MyComponent))).Returns(true);
var path = new PropertyPath(null, ForClass <MyClass> .Property(p => p.Components));
pattern.Match(path).Should().Be.True();
}
public void WhenManySideIsNotAnEntityThenNoMatch()
{
var orm = new ObjectRelationalMapper();
orm.TablePerClass <MyRoot1>();
orm.TablePerClass <MyRoot2>();
var pattern = new PolymorphismBidirectionalAnyToManyPattern(orm);
pattern.Match(ForClass <MyRelatedNoRoot1> .Property(x => x.Items)).Should().Be.False();
}
public void WhenTheDomainDoesNotContainMoreImplsThenNoMatch()
{
var orm = new ObjectRelationalMapper();
orm.TablePerClass <MyEntity>();
orm.TablePerClass <MyRoot1>();
var pattern = new PolymorphismBidirectionalAnyToManyPattern(orm);
pattern.Match(ForClass <MyRelatedNoRoot1> .Property(x => x.Items)).Should().Be.False();
}
public void CanSetProxy()
{
var mapdoc = new HbmMapping();
var rc = new ClassMapper(typeof(EntityProxable), mapdoc, ForClass <EntityProxable> .Property(x => x.Id));
rc.Proxy(typeof(IEntityProxable));
var hbmEntity = mapdoc.RootClasses[0];
hbmEntity.Proxy.Should().Contain("IEntityProxable");
}
public void CanMapManyToOne()
{
var mapdoc = new HbmMapping();
var component = new HbmNestedCompositeElement();
var mapper = new ComponentNestedElementMapper(typeof(Number), mapdoc, component, ForClass <Address> .Property(a => a.Number));
mapper.ManyToOne(ForClass <Number> .Property(a => a.Parent), x => { });
component.Properties.Should().Have.Count.EqualTo(1);
component.Properties.First().Name.Should().Be.EqualTo("Parent");
component.Properties.First().Should().Be.OfType <HbmManyToOne>();
}
public void WhenDictionaryIsInPlainEntityThenApplyClassNamePropertyName()
{
var orm = new Mock <IDomainInspector>();
var pattern = new CollectionOfElementsTableApplier(orm.Object);
var mapper = new Mock <ICollectionPropertiesMapper>();
var path = new PropertyPath(null, ForClass <MyClass> .Property(p => p.MapOfStrings));
pattern.Match(path).Should().Be.True();
pattern.Apply(path, mapper.Object);
mapper.Verify(km => km.Table(It.Is <string>(s => s == "MyClassMapOfStrings")));
}
public void GetContainerEntityWhenPropertyIsInComponentThenReturnEntity()
{
var orm = new Mock <IDomainInspector>();
orm.Setup(x => x.IsEntity(typeof(MainEntity))).Returns(true);
orm.Setup(x => x.IsRootEntity(typeof(MainEntity))).Returns(true);
orm.Setup(x => x.IsEntity(typeof(InheritedEntity))).Returns(true);
var level0 = new PropertyPath(null, ForClass <InheritedEntity> .Property(p => p.Component));
var path = new PropertyPath(level0, ForClass <MyComponent> .Property(p => p.Something));
path.GetContainerEntity(orm.Object).Should().Be(typeof(InheritedEntity));
}
public void WhenSetTypeByITypeTypeThenSetType()
{
var member = ForClass <MyClass> .Property(c => c.EnumProp);
var mapping = new HbmKeyProperty();
var mapper = new KeyPropertyMapper(member, mapping);
mapper.Type <EnumStringType <MyEnum> >();
mapping.Type.name.Should().Contain(typeof(EnumStringType <MyEnum>).FullName);
mapping.type.Should().Be.Null();
}
public void WhenNoPolymorphicThenNoMatch()
{
// using the concrete implementation of IDomainInspector this test is more like an integration-test but it is exactly what I need.
var orm = new ObjectRelationalMapper();
orm.TablePerClass <Parent>();
orm.TablePerClass <Child>();
var pattern = new PolymorphismBidirectionalOneToManyMemberPattern(orm);
pattern.Match(ForClass <Parent> .Property(x => x.Children)).Should().Be.False();
}
public void WhenSetFormulaWithNullThenDoNothing()
{
var member = ForClass <MyClass> .Property(c => c.Autoproperty);
var mapping = new HbmProperty();
var mapper = new PropertyMapper(member, mapping);
mapper.Column("MyColumn");
mapper.Formula(null);
mapping.formula.Should().Be.Null();
mapping.column.Should().Not.Be.Null();
}
public void WhenRelationDeclaredAsManyToManyBidirectionalThenMatch()
{
var orm = new Mock <IDomainInspector>();
orm.Setup(x => x.IsManyToMany(It.Is <Type>(t => t == typeof(MyClass)), It.Is <Type>(t => t == typeof(MyBidirect)))).Returns(true);
orm.Setup(x => x.IsManyToMany(It.Is <Type>(t => t == typeof(MyBidirect)), It.Is <Type>(t => t == typeof(MyClass)))).Returns(true);
var pattern = new ManyToManyPattern(orm.Object);
pattern.Match(ForClass <MyClass> .Property(x => x.MyBidirects)).Should().Be.True();
pattern.Match(ForClass <MyBidirect> .Property(x => x.MyClasses)).Should().Be.True();
}
public void WhenInterfaceOnChildAndPropertyExclusionOnInterfaceThenNoMatch()
{
var orm = new ObjectRelationalMapper();
orm.TablePerClass <Parent>();
orm.TablePerClass <Child>();
orm.ExcludeProperty <IChild>(c => c.Parent);
var pattern = new PolymorphismBidirectionalOneToManyMemberPattern(orm);
pattern.Match(ForClass <Parent> .Property(x => x.Children)).Should().Be.False();
}
public void WhenInComponentThenApplyPropertyPath()
{
var applier = new ManyToOneColumnApplier();
var level0 = new PropertyPath(null, ForClass <MyClass> .Property(x => x.Component));
var path = new PropertyPath(level0, ForClass <MyComponent> .Property(x => x.AnotherClass));
var mayToOneMapper = new Mock <IManyToOneMapper>();
applier.Match(path).Should().Be.True();
applier.Apply(path, mayToOneMapper.Object);
mayToOneMapper.Verify(x => x.Column(It.Is <string>(columnName => columnName == "ComponentAnotherClassId")));
}
public void SettingColumnOverridesFormula()
{
var hbmMapping = new HbmMapping();
var member = ForClass <MyClass> .Property(c => c.Relation);
var mapping = new HbmManyToOne();
var mapper = new ManyToOneMapper(member, mapping, hbmMapping);
mapper.Formula("formula");
mapper.Column(cm => cm.Unique(true));
mapping.formula.Should().Be.Null();
}
public void SettingColumnPlainValuesOverridesFormula()
{
var member = ForClass <MyClass> .Property(c => c.Autoproperty);
var mapping = new HbmProperty();
var mapper = new PropertyMapper(member, mapping);
mapper.Formula("formula");
mapper.Column("colName");
mapping.formula.Should().Be.Null();
mapping.column.Should().Be("colName");
}
public void WhenRelationIsNotOneToManyThenNoMatch()
{
var orm = new Mock <IDomainInspector>();
var pattern = new OneToManyKeyColumnApplier(orm.Object);
orm.Setup(x => x.IsOneToMany(It.Is <Type>(t => t == typeof(MyClass)), It.Is <Type>(t => t == typeof(MyRelated)))).Returns(false);
var pathCollection = new PropertyPath(null, ForClass <MyClass> .Property(p => p.Relateds));
var pathMap = new PropertyPath(null, ForClass <MyClass> .Property(p => p.Map));
pattern.Match(pathCollection).Should().Be.False();
pattern.Match(pathMap).Should().Be.False();
}
public void SettingFormulaOverridesColumn()
{
var member = ForClass <MyClass> .Property(c => c.Autoproperty);
var mapping = new HbmProperty();
var mapper = new PropertyMapper(member, mapping);
mapper.Column(cm => cm.Unique(true));
mapper.Formula("formula");
mapping.formula.Should().Be("formula");
mapping.Items.Should().Be.Null();
}
public void CanMapProperty()
{
var mapdoc = new HbmMapping();
var component = new HbmNestedCompositeElement();
var mapper = new ComponentNestedElementMapper(typeof(Number), mapdoc, component, ForClass <Address> .Property(a => a.Number));
mapper.Property(ForClass <Number> .Property(a => a.Block), x => { });
mapper.Property(ForClass <Number> .Property(a => a.Dir), x => { });
component.Properties.Should().Have.Count.EqualTo(2);
component.Properties.Select(cp => cp.Name).Should().Have.SameValuesAs("Block", "Dir");
}
public void WhenRelationIsOneToManyInsideComponentThenNoMatch()
{
var orm = new Mock <IDomainInspector>();
var pattern = new CollectionOfElementsColumnApplier(orm.Object);
orm.Setup(x => x.IsOneToMany(It.Is <Type>(t => t == typeof(MyComponent)), It.Is <Type>(t => t == typeof(MyRelated)))).Returns(true);
var level0 = new PropertyPath(null, ForClass <MyClass> .Property(p => p.Component));
var path = new PropertyPath(level0, ForClass <MyComponent> .Property(p => p.Relateds));
pattern.Match(path).Should().Be.False();
}
private Mock <IDomainInspector> GetMockedDomainInspector()
{
var orm = new Mock <IDomainInspector>();
orm.Setup(m => m.IsEntity(It.IsAny <Type>())).Returns(true);
orm.Setup(m => m.IsRootEntity(It.IsAny <Type>())).Returns(true);
orm.Setup(m => m.IsTablePerClass(It.IsAny <Type>())).Returns(true);
orm.Setup(m => m.IsPersistentId(It.Is <MemberInfo>(mi => mi.Name == "Id"))).Returns(true);
orm.Setup(m => m.IsPersistentProperty(It.Is <MemberInfo>(mi => mi.Name != "Id"))).Returns(true);
orm.Setup(m => m.IsDictionary(It.Is <MemberInfo>(mi => mi == ForClass <MyClass> .Property(p => p.Dictionary)))).Returns(true);
return(orm);
}
public void CanMapManyToOne()
{
var mapdoc = new HbmMapping();
var component = new HbmCompositeMapKey();
var mapper = new ComponentMapKeyMapper(typeof(ToySkill), component, mapdoc);
mapper.ManyToOne(ForClass <ToySkill> .Property(ts => ts.Skill), x => { });
component.Properties.Should().Have.Count.EqualTo(1);
component.Properties.First().Name.Should().Be.EqualTo("Skill");
component.Properties.First().Should().Be.OfType <HbmKeyManyToOne>();
}
public void WhenCollectionOfElementsInsideComponentThenApplyPropertyPathNameElement()
{
var orm = new Mock <IDomainInspector>();
var pattern = new CollectionOfElementsColumnApplier(orm.Object);
var mapper = new Mock <IElementMapper>();
var level0 = new PropertyPath(null, ForClass <MyClass> .Property(p => p.Component));
var path = new PropertyPath(level0, ForClass <MyComponent> .Property(p => p.Strings));
pattern.Apply(path, mapper.Object);
mapper.Verify(elementMapper => elementMapper.Column(It.Is <string>(s => s == "ComponentStringsElement")));
}
public void WhenSetFormulaWithNullThenDoNothing()
{
var hbmMapping = new HbmMapping();
var member = ForClass <MyClass> .Property(c => c.Relation);
var mapping = new HbmManyToOne();
var mapper = new ManyToOneMapper(member, mapping, hbmMapping);
mapper.Column("MyColumn");
mapper.Formula(null);
mapping.formula.Should().Be.Null();
mapping.column.Should().Not.Be.Null();
}