private void VerifyMapping(HbmMapping mapping)
{
HbmClass rc = mapping.RootClasses.First(r => r.Name.Contains("Person"));
var relation = rc.Properties.First(p => p.Name == "Addresses");
var collection = (HbmBag)relation;
collection.ElementRelationship.Should().Be.OfType <HbmCompositeElement>();
var elementRelation = (HbmCompositeElement)collection.ElementRelationship;
elementRelation.Class.Should().Contain("Address");
elementRelation.Properties.Should().Have.Count.EqualTo(2);
elementRelation.Properties.Select(p => p.Name).Should().Have.SameValuesAs("Street", "Number");
elementRelation.Parent.Should().Not.Be.Null();
elementRelation.Parent.name.Should().Be.EqualTo("Owner");
// Nested
var propertyNestedRelation = elementRelation.Properties.FirstOrDefault(p => p.Name == "Number");
propertyNestedRelation.Should().Not.Be.Null().And.Be.OfType <HbmNestedCompositeElement>();
var nestedRelation = (HbmNestedCompositeElement)propertyNestedRelation;
nestedRelation.Class.Should().Contain("Number");
nestedRelation.Properties.Should().Have.Count.EqualTo(1);
nestedRelation.Parent.Should().Not.Be.Null();
nestedRelation.Parent.name.Should().Be.EqualTo("OwnerAddress");
}
public void WhenSpecifiedThenSetDifferentConfigurationForSameComponent()
{
Mock <IDomainInspector> orm = GetMockedDomainInspector();
var domainInspector = orm.Object;
var mapper = new Mapper(domainInspector);
mapper.Class <Person>(c =>
{
c.Component(p => p.RealName, cname =>
{
cname.Property(cnp => cnp.First, pm => pm.Length(50));
cname.Property(cnp => cnp.Last, pm => pm.Length(51));
});
c.Component(p => p.Aka, cname =>
{
cname.Property(cnp => cnp.First, pm => pm.Length(20));
cname.Property(cnp => cnp.Last, pm => pm.Length(21));
});
});
HbmMapping mapping = mapper.CompileMappingFor(new[] { typeof(Person) });
HbmClass rc = mapping.RootClasses.First(r => r.Name.Contains("Person"));
var hbmRealName = (HbmComponent)rc.Properties.First(p => p.Name == "RealName");
var hbmAka = (HbmComponent)rc.Properties.First(p => p.Name == "Aka");
hbmRealName.Properties.OfType <HbmProperty>().Select(p => p.length).Should().Have.SameValuesAs("50", "51");
hbmAka.Properties.OfType <HbmProperty>().Select(p => p.length).Should().Have.SameValuesAs("20", "21");
}
private void VerifyMapping(HbmMapping mapping)
{
HbmClass rc = mapping.RootClasses.First(r => r.Name.Contains("Person"));
var relation = rc.Properties.First(p => p.Name == "Addresses");
var collection = (HbmBag)relation;
collection.ElementRelationship.Should().Be.OfType <HbmCompositeElement>();
var elementRelation = (HbmCompositeElement)collection.ElementRelationship;
elementRelation.Class.Should().Contain("Address");
// This test was modified because when the "owner" is an entity it can be mapped as many-to-one or as parent and without an explicit
// definition of the property representing the bidiretional-relation we can't know is the mapping element (many-to-one or parent)
elementRelation.Properties.Should().Have.Count.EqualTo(3);
elementRelation.Properties.Select(p => p.Name).Should().Have.SameValuesAs("Street", "Number", "Owner");
//elementRelation.Parent.Should().Not.Be.Null();
//elementRelation.Parent.name.Should().Be.EqualTo("Owner");
// Nested
var propertyNestedRelation = elementRelation.Properties.FirstOrDefault(p => p.Name == "Number");
propertyNestedRelation.Should().Not.Be.Null().And.Be.OfType <HbmNestedCompositeElement>();
var nestedRelation = (HbmNestedCompositeElement)propertyNestedRelation;
nestedRelation.Class.Should().Contain("Number");
nestedRelation.Properties.Should().Have.Count.EqualTo(1);
nestedRelation.Parent.Should().Not.Be.Null();
nestedRelation.Parent.name.Should().Be.EqualTo("OwnerAddress");
}
public void ShouldMapPropertiesOfSuperClasses()
{
var orm = new Mock <IDomainInspector>();
orm.Setup(m => m.IsEntity(It.Is <Type>(t => t != typeof(Name)))).Returns(true);
orm.Setup(m => m.IsRootEntity(It.Is <Type>(t => t != typeof(Name)))).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.IsComponent(It.Is <Type>(t => t == typeof(Name)))).Returns(true);
var mapper = new Mapper(orm.Object);
var mapping = mapper.CompileMappingFor(new[] { typeof(Person) });
HbmClass rc = mapping.RootClasses.First(r => r.Name.Contains("Person"));
rc.Properties.Should().Have.Count.EqualTo(1);
rc.Properties.Select(p => p.Name).Should().Have.SameValuesAs("Name");
var relation = rc.Properties.First(p => p.Name == "Name");
relation.Should().Be.OfType <HbmComponent>();
var component = (HbmComponent)relation;
component.Properties.Should().Have.Count.EqualTo(2);
component.Properties.Select(p => p.Name).Should().Have.SameValuesAs("First", "Last");
}
private static string GetFileName(HbmMapping hbmMapping)
{
string name = "MyMapping";
HbmClass rc = hbmMapping.RootClasses.FirstOrDefault();
if (rc != null)
{
name = rc.Name;
}
HbmSubclass sc = hbmMapping.SubClasses.FirstOrDefault();
if (sc != null)
{
name = sc.Name;
}
HbmJoinedSubclass jc = hbmMapping.JoinedSubclasses.FirstOrDefault();
if (jc != null)
{
name = jc.Name;
}
HbmUnionSubclass uc = hbmMapping.UnionSubclasses.FirstOrDefault();
if (uc != null)
{
name = uc.Name;
}
return(name + ".hbm.xml");
}
public void WhenPropertyUsedAsComposedIdAndPropertiesAndNaturalIdThenMapOnlyAsComposedId()
{
var mapper = new ModelMapper();
mapper.Class <MyClass>(map =>
{
map.ComposedId(cm =>
{
cm.Property(x => x.Code);
cm.ManyToOne(x => x.Relation);
});
map.NaturalId(nm =>
{
nm.Property(x => x.Code);
nm.ManyToOne(x => x.Relation);
});
map.Property(x => x.Code);
map.ManyToOne(x => x.Relation);
}
);
HbmMapping hbmMapping = mapper.CompileMappingFor(new[] { typeof(MyClass) });
HbmClass hbmClass = hbmMapping.RootClasses[0];
HbmCompositeId hbmCompositId = hbmClass.CompositeId;
hbmCompositId.Items.Should().Have.Count.EqualTo(2);
hbmClass.naturalid.Should().Be.Null();
hbmClass.Properties.Should().Be.Empty();
}
public void WhenCustomizeNestedCompositeElementPropertiesAt3thLevelThenExecuteTheCustomizationOnTheSpecificMemberPath()
{
Mock <IDomainInspector> orm = GetMockedDomainInspector();
var domainInspector = orm.Object;
var mapper = new Mapper(domainInspector);
mapper.Class <MyClass>(map => map.Bag(myClass => myClass.Components, x => { },
rel => rel.Component(cm =>
cm.Component(myclass => myclass.ComponentLevel1,
c1m => c1m.Component(c1 => c1.ComponentLevel2, compo => compo.Property(cl1 => cl1.Something2, m => m.Column("MyColName"))))
)));
HbmMapping mapping = mapper.CompileMappingFor(new[] { typeof(MyClass) });
HbmClass rc = mapping.RootClasses.First(r => r.Name.Contains("MyClass"));
var collection = (HbmBag)rc.Properties.First(p => p.Name == "Components");
var relation = (HbmCompositeElement)collection.ElementRelationship;
relation.Should().Be.OfType <HbmCompositeElement>();
var component1 = (HbmNestedCompositeElement)relation.Properties.First(p => p.Name == "ComponentLevel1");
var component2 = (HbmNestedCompositeElement)component1.Properties.First(p => p.Name == "ComponentLevel2");
var property = (HbmProperty)component2.Properties.First(p => p.Name == "Something2");
property.column.Should().Be("MyColName");
}
public void WhenPropertyUsedAsComposedIdAndPropertiesAndNaturalIdThenMapOnlyAsComposedId()
{
var mapper = new ModelMapper();
mapper.Class <MyClass>(map =>
{
map.ComposedId(cm =>
{
cm.Property(x => x.Code);
cm.ManyToOne(x => x.Relation);
});
map.NaturalId(nm =>
{
nm.Property(x => x.Code);
nm.ManyToOne(x => x.Relation);
});
map.Property(x => x.Code);
map.ManyToOne(x => x.Relation);
}
);
HbmMapping hbmMapping = mapper.CompileMappingFor(new[] { typeof(MyClass) });
HbmClass hbmClass = hbmMapping.RootClasses[0];
HbmCompositeId hbmCompositId = hbmClass.CompositeId;
Assert.That(hbmCompositId.Items, Has.Length.EqualTo(2));
Assert.That(hbmClass.naturalid, Is.Null);
Assert.That(hbmClass.Properties, Is.Empty);
}
public void WhenCustomizeNestedComponentParentAccessThroughCollectionThenApplyCustomizationToMappingForCompositeElement()
{
Mock <IDomainInspector> orm = GetMockedDomainInspector();
var domainInspector = orm.Object;
var mapper = new Mapper(domainInspector);
mapper.Class <MyClass>(
ca =>
ca.Bag(mycomponent => mycomponent.Components, x => { },
cer =>
cer.Component(
c =>
c.Component(mycomponent => mycomponent.Component,
ce => ce.Parent(mync => mync.Parent, pa => pa.Access(Accessor.Field))))));
HbmMapping mapping = mapper.CompileMappingFor(new[] { typeof(MyClass) });
HbmClass rc = mapping.RootClasses.First(r => r.Name.Contains("MyClass"));
var hbmBag = (HbmBag)rc.Properties.First(p => p.Name == "Components");
var hbmCompositeElement = (HbmCompositeElement)hbmBag.ElementRelationship;
var hbmNestedCompositeElement = (HbmNestedCompositeElement)hbmCompositeElement.Properties.First(p => p.Name == "Component");
hbmNestedCompositeElement.Parent.name.Should().Be("Parent");
hbmNestedCompositeElement.Parent.access.Should().Be("field.camelcase-underscore");
}
public MappedClassInfo(HbmClass classInfo, string fileName)
{
FileName = fileName;
_classInfo = classInfo;
Properties = new List <MappedPropertyInfo>();
if (classInfo.Id != null)
{
Properties.Add(new MappedPropertyInfo(classInfo.Id, fileName));
}
if (classInfo.Items != null)
{
Properties.AddRange(_classInfo.Items.Select(x => new MappedPropertyInfo(x, fileName)));
}
string[] parts = classInfo.name.Split(new[] { ',' });
ClassName = parts[0];
if (parts.Length > 1)
{
AssemblyName = parts[1].Trim();
}
Mutable = classInfo.mutable;
Cache = classInfo.cache;
TableName = classInfo.table;
}
public void Bind(HbmClass classSchema, IDictionary <string, MetaAttribute> inheritedMetas)
{
var rootClass = new RootClass();
BindClass(classSchema, rootClass, inheritedMetas);
// OPTIMISTIC LOCK MODE
rootClass.OptimisticLockMode = classSchema.optimisticlock.ToOptimisticLock();
inheritedMetas = GetMetas(classSchema, inheritedMetas, true); // get meta's from <class>
//TABLENAME
string schema = classSchema.schema ?? mappings.SchemaName;
string catalog = classSchema.catalog ?? mappings.CatalogName;
string tableName = GetClassTableName(rootClass, classSchema);
if (string.IsNullOrEmpty(tableName))
{
throw new MappingException(
string.Format(
"Could not determine the name of the table for entity '{0}'; remove the 'table' attribute or assign a value to it.",
rootClass.EntityName));
}
Table table = mappings.AddTable(schema, catalog, tableName, classSchema.Subselect, rootClass.IsAbstract.GetValueOrDefault(), classSchema.schemaaction);
((ITableOwner)rootClass).Table = table;
log.Info("Mapping class: {0} -> {1}", rootClass.EntityName, rootClass.Table.Name);
rootClass.IsMutable = classSchema.mutable;
rootClass.Where = classSchema.where ?? rootClass.Where;
if (classSchema.check != null)
{
table.AddCheckConstraint(classSchema.check);
}
rootClass.IsExplicitPolymorphism = classSchema.polymorphism == HbmPolymorphismType.Explicit;
BindCache(classSchema.cache, rootClass);
new ClassIdBinder(Mappings).BindId(classSchema.Id, rootClass, table);
new ClassCompositeIdBinder(Mappings).BindCompositeId(classSchema.CompositeId, rootClass);
new ClassDiscriminatorBinder(rootClass, Mappings).BindDiscriminator(classSchema.discriminator, table);
BindTimestamp(classSchema.Timestamp, rootClass, table, inheritedMetas);
BindVersion(classSchema.Version, rootClass, table, inheritedMetas);
rootClass.CreatePrimaryKey();
BindNaturalId(classSchema.naturalid, rootClass, inheritedMetas);
new PropertiesBinder(mappings, rootClass).Bind(classSchema.Properties, inheritedMetas);
BindJoins(classSchema.Joins, rootClass, inheritedMetas);
BindSubclasses(classSchema.Subclasses, rootClass, inheritedMetas);
BindJoinedSubclasses(classSchema.JoinedSubclasses, rootClass, inheritedMetas);
BindUnionSubclasses(classSchema.UnionSubclasses, rootClass, inheritedMetas);
new FiltersBinder(rootClass, Mappings).Bind(classSchema.filter);
mappings.AddClass(rootClass);
}
private void VerifyEntitySimpleMapping(HbmMapping mapping)
{
mapping.RootClasses.Should().Have.Count.EqualTo(1);
HbmClass rc = mapping.RootClasses.Single();
rc.Id.Should().Not.Be.Null();
rc.Properties.Should().Have.Count.EqualTo(1);
rc.Properties.First().Name.Should().Be.EqualTo("Name");
}
public void WhenAutoPropertyThenProperty()
{
var mapper = MyOtherClassScenario();
var mapping = mapper.CompileMappingFor(new[] { typeof(MyOtherClass) });
HbmClass rc = mapping.RootClasses.Single();
rc.Properties.First(p => p.Name == "AProp").Access.Should().Be.Null();
}
public NaturalIdMapper(System.Type rootClass, HbmClass classMapping, HbmMapping mapDoc) : base(rootClass, mapDoc)
{
if (classMapping == null)
{
throw new ArgumentNullException("classMapping");
}
this.classMapping = classMapping;
naturalIdmapping = new HbmNaturalId();
}
public void WhenNosetterPropertyWithoutFieldThenReadOnly()
{
var mapper = MyOtherClassScenario();
var mapping = mapper.CompileMappingFor(new[] { typeof(MyOtherClass) });
HbmClass rc = mapping.RootClasses.Single();
rc.Properties.First(p => p.Name == "PropertyWithoutField").Access.Should().Be.EqualTo("readonly");
}
public void WhenNosetterPropertyWithFieldThenFieldOnSet()
{
var mapper = MyOtherClassScenario();
var mapping = mapper.CompileMappingFor(new[] { typeof(MyOtherClass) });
HbmClass rc = mapping.RootClasses.Single();
rc.Properties.First(p => p.Name == "ReadOnlyWithSameBackField").Access.Should().Be.EqualTo("nosetter.camelcase");
}
public void WhenDifferentPropertyTypeThenField()
{
var mapper = MyOtherClassScenario();
var mapping = mapper.CompileMappingFor(new[] { typeof(MyOtherClass) });
HbmClass rc = mapping.RootClasses.Single();
rc.Properties.First(p => p.Name == "WithDifferentBackField").Access.Should().Be.EqualTo("field.camelcase");
}
private void VerifyMappingContainsClassWithComponentAndParent(HbmMapping mapping)
{
HbmClass rc = mapping.RootClasses.First(r => r.Name.Contains("MyClass"));
var relation = (HbmBag)rc.Properties.First(p => p.Name == "Components");
var component = (HbmCompositeElement)relation.ElementRelationship;
component.Parent.Should().Not.Be.Null();
component.Parent.name.Should().Be.EqualTo("Owner");
}
private void VerifyMapping(HbmMapping mapping)
{
HbmClass rc = mapping.RootClasses.First(r => r.Name.Contains("Node"));
var relation = rc.Properties.First(p => p.Name == "Children");
relation.Should().Be.OfType <HbmBag>();
var collection = (HbmBag)relation;
collection.Key.ondelete.Should().Be.EqualTo(HbmOndelete.Noaction);
}
private void VerifyMappingWithCascade(HbmMapping mapping)
{
HbmClass rc = mapping.RootClasses.First(r => r.Name.Contains("AEntity"));
rc.Properties.Should().Have.Count.EqualTo(2);
rc.Properties.Select(p => p.Name).Should().Have.SameValuesAs("Name", "B");
var relation = rc.Properties.First(p => p.Name == "B");
((HbmManyToOne)relation).cascade.Should().Contain("persist").And.Contain("delete");
}
public void WhenReadOnlyPersistentPropertyWithBackfieldThenUseAccessField()
{
// by default, if the property does not have setter it should use field
Mapper mapper = MyClassScenario();
var mapping = mapper.CompileMappingFor(new[] { typeof(MyClass) });
HbmClass rc = mapping.RootClasses.Single();
rc.Properties.First(p => p.Name == "ReadOnlyWithField").Access.Should().Be.EqualTo("nosetter.camelcase");
}
private void ByDefaultShouldAssignTheAccessorForParentProperty(HbmMapping mapping)
{
HbmClass rc = mapping.RootClasses.First(r => r.Name.Contains("Person"));
var relation = rc.Properties.First(p => p.Name == "Name");
var component = (HbmComponent)relation;
component.Parent.Should().Not.Be.Null();
component.Parent.name.Should().Be.EqualTo("Owner");
component.Parent.access.Should().Contain("camelcase");
}
private void VerifyEntitySimpleMapping(HbmMapping mapping)
{
mapping.RootClasses.Should().Have.Count.EqualTo(1);
HbmClass rc = mapping.RootClasses.Single();
rc.Id.Should().Not.Be.Null();
rc.Properties.Should().Have.Count.EqualTo(0);
rc.discriminator.Should().Be.Null();
rc.IsAbstract.Should().Be.EqualTo(true);
}
private void VerifyMapping(HbmMapping mapping)
{
HbmClass rc = mapping.RootClasses.Single();
rc.Properties.Should().Have.Count.EqualTo(1);
rc.Properties.Single().Should().Be.OfType <HbmProperty>();
var propertyMapping = (HbmProperty)rc.Properties.Single();
propertyMapping.Name.Should().Be.EqualTo("Amount");
propertyMapping.Type.Should("The persistent type can't be inferred at this point (IUserType in NH)").Be.Null();
}
public void WhenExplicitFieldAccessThenUseAccessField()
{
var mapper = MyClassScenario();
mapper.Customize <MyClass>(cm => cm.Property(mc => mc.ReadOnlyWithField, pm => pm.Access(Accessor.Field)));
var mapping = mapper.CompileMappingFor(new[] { typeof(MyClass) });
HbmClass rc = mapping.RootClasses.Single();
rc.Properties.First(p => p.Name == "ReadOnlyWithField").Access.Should().Be.EqualTo("field.camelcase");
}
private void VerifyMappingContainsClassWithComponentAndParent(HbmMapping mapping)
{
HbmClass rc = mapping.RootClasses.First(r => r.Name.Contains("MyClass"));
var relation = rc.Properties.First(p => p.Name == "Component");
relation.Should().Be.InstanceOf <HbmComponent>();
var component = (HbmComponent)relation;
component.Parent.Should().Not.Be.Null();
component.Parent.name.Should().Be.EqualTo("Owner");
}
private string GetClassTableName(PersistentClass model, HbmClass classSchema)
{
if (classSchema.table == null)
{
return(mappings.NamingStrategy.ClassToTableName(model.EntityName));
}
else
{
return(mappings.NamingStrategy.TableName(classSchema.table.Trim()));
}
}
public void WhenCustomerIsTheMasterThenApplyPropertyRefOnCustomerPropertyInAddress()
{
Mock <IDomainInspector> orm = GetOrmMockCustomerToAddress();
var mapper = new Mapper(orm.Object);
var mappings = mapper.CompileMappingFor(new[] { typeof(Address) });
HbmClass address = mappings.RootClasses.Single();
HbmOneToOne addressCustomer = address.Properties.OfType <HbmOneToOne>().Single();
addressCustomer.propertyref.Should().Be("Address");
}
public void WhenAddressIsTheMasterThenApplyPropertyRefOnAddressPropertyInCustomer()
{
Mock <IDomainInspector> orm = GetOrmMockAddressToCustomer();
var mapper = new Mapper(orm.Object);
var mappings = mapper.CompileMappingFor(new[] { typeof(Customer) });
HbmClass customer = mappings.RootClasses.Single();
HbmOneToOne customerAddress = customer.Properties.OfType <HbmOneToOne>().Single();
customerAddress.propertyref.Should().Be("Customer");
}
private void VerifyMapping(HbmMapping mapping)
{
HbmClass rc = mapping.RootClasses.First(r => r.Name.Contains("Person"));
rc.Properties.Should().Have.Count.EqualTo(1);
var relation = rc.Properties.First(p => p.Name == "Pets");
relation.Should().Be.OfType <HbmBag>();
var collection = (HbmBag)relation;
collection.cascade.Should().Contain("save-update");
}
