public void ShouldAddIdToClass() { var classMap = new ClassMapping() { Type = typeof(IdClass)}; var mapper = new IdAutoMapper(); mapper.Map(classMap); Assert.IsNotNull(classMap.Id); }
public void Should_produce_valid_hbm() { var classMapping = new ClassMapping {Name = "class1", Id = new IdMapping()}; _mocker.Get<IHbmWriter<IIdentityMapping>>() .Expect(x => x.Write(classMapping.Id)).Return(new HbmId { generator = new HbmGenerator { @class = "native" } }); _classWriter.ShouldGenerateValidOutput(classMapping); }
public void ShouldSetIdAsProperty() { var classMap = new ClassMapping() { Type = typeof(IdClass) }; var mapper = new IdAutoMapper(); mapper.Map(classMap); var id = classMap.Id as IdMapping; Assert.AreEqual(id.MappedMember.Name, "Id"); }
protected virtual void BindClass(ClassMapping classMapping, PersistentClass clazz) { Type type = classMapping.Type; string entityName = type.FullName; clazz.EntityName = entityName; clazz.ClassName = type.AssemblyQualifiedName; BindPocoRepresentation(classMapping, clazz); BindPersistentClassCommonValues(classMapping, clazz); }
public void Should_write_the_components() { var classMapping = new ClassMapping(); classMapping.AddComponent(new ComponentMapping()); _mocker.Get<IHbmWriter<ComponentMapping>>() .Expect(x => x.Write(classMapping.Components.First())).Return(new HbmComponent()); _classWriter.VerifyXml(classMapping) .Element("component").Exists(); }
public void ShouldSetColumnNameToMatchPropertyName() { var classMap = new ClassMapping() { Type = typeof(IdClass) }; var mapper = new IdAutoMapper(); mapper.Map(classMap); var id = classMap.Id as IdMapping; var column = id.Columns.FirstOrDefault(); Assert.AreEqual(column.Name, "Id"); }
public void Should_write_the_collections() { var classMapping = new ClassMapping(); classMapping.AddCollection(new BagMapping()); _mocker.Get<IHbmWriter<ICollectionMapping>>() .Expect(x => x.Write(classMapping.Collections.First())) .Return(new HbmBag()); _classWriter.VerifyXml(classMapping) .Element("bag").Exists(); }
public void Map(ClassMapping classMap) { var idProperty = classMap.Type.GetProperty("Id"); var columnMapping = new ColumnMapping { Name = "Id", MappedMember = idProperty }; var mapping = new IdMapping(columnMapping) { Name = "Id", Generator = new IdGeneratorMapping() }; mapping.BindToMember(idProperty); classMap.Id = mapping; }
public void Map(ClassMapping classMap) { foreach(var property in classMap.Type.GetProperties()) { if (!classMap.HasMappedProperty(property)) { if (property.PropertyType.Namespace == "System") { var propMapping = new PropertyMapping {Name = property.Name}; propMapping.BindToMember(property); classMap.AddProperty(propMapping); } } } }
protected virtual void BindPersistentClassCommonValues(ClassMapping classMapping, PersistentClass model) { //TODO: Introduce all those model.DiscriminatorValue = model.EntityName; model.DynamicUpdate = false; ; model.DynamicInsert = false; string qualifiedName = model.MappedClass == null ? model.EntityName : model.MappedClass.AssemblyQualifiedName; mappings.AddImport(qualifiedName, model.EntityName); if (mappings.IsAutoImport && model.EntityName.IndexOf('.') > 0) mappings.AddImport(qualifiedName, StringHelper.Unqualify(model.EntityName)); model.BatchSize = 0; model.SelectBeforeUpdate = false; model.OptimisticLockMode = NHibernate.Engine.Versioning.OptimisticLock.Version; model.IsAbstract = false; model.IsLazy = true; }
public virtual void Bind(ClassMapping classMapping) { RootClass rootClass = new RootClass(); BindClass(classMapping, rootClass); string schema = mappings.SchemaName; string catalog = mappings.CatalogName; string tableName = classMapping.Tablename.ValueOrDefault( mappings.NamingStrategy.TableName(classMapping.Type.Name)); Table table = mappings .AddTable(schema, catalog, tableName, null, rootClass.IsAbstract.GetValueOrDefault());//Introduce SchemaAction ((ITableOwner)rootClass).Table = table; rootClass.IsMutable = true; rootClass.IsExplicitPolymorphism = false; new ClassIdBinder(this).BindId(classMapping.Id as IdMapping, rootClass, table); rootClass.CreatePrimaryKey(dialect); base.BindProperties(rootClass, classMapping); mappings.AddClass(rootClass); }
public void Should_pass_the_discriminator_to_the_visitor() { var classMap = new ClassMapping {Name = "class1" }; classMap.Discriminator = new DiscriminatorMapping(); var visitor = MockRepository.GenerateMock<IMappingModelVisitor>(); visitor.Expect(x => x.Visit(classMap.Discriminator)); classMap.AcceptVisitor(visitor); visitor.VerifyAllExpectations(); }
public void Should_pass_subclasses_to_the_visitor() { var classMap = new ClassMapping {Name = "class1" }; classMap.AddSubclass(new JoinedSubclassMapping()); var visitor = MockRepository.GenerateMock<IMappingModelVisitor>(); visitor.Expect(x => x.Visit(classMap.Subclasses.First())); classMap.AcceptVisitor(visitor); visitor.VerifyAllExpectations(); }
public void Should_not_pass_null_id_to_the_visitor() { var classMap = new ClassMapping {Name = "class1" }; classMap.Id = null; var visitor = MockRepository.GenerateMock<IMappingModelVisitor>(); visitor.Expect(x => x.Visit(classMap.Id)).Repeat.Never(); classMap.AcceptVisitor(visitor); visitor.VerifyAllExpectations(); }
public void AddClass(ClassMapping classMapping) { _classes.Add(classMapping); }
public void Should_clear_the_parent_class_for_the_discriminator() { var classMap = new ClassMapping {Name = "class1" }; var discriminator = new DiscriminatorMapping(); classMap.Discriminator = discriminator; classMap.Discriminator = null; discriminator.ParentClass.ShouldBeNull(); }
public virtual void Visit(ClassMapping classMapping) { }
public override void ProcessClass(ClassMapping classMapping) { ProcessClassBase(classMapping); }
public void Should_write_the_subclasses() { var classMapping = new ClassMapping(); classMapping.AddSubclass(new JoinedSubclassMapping()); _mocker.Get<IHbmWriter<ISubclassMapping>>() .Expect(x => x.Write(classMapping.Subclasses.First())) .Return(new HbmJoinedSubclass()); _classWriter.VerifyXml(classMapping) .Element("joined-subclass").Exists(); }
public void Should_write_the_references() { var classMapping = new ClassMapping(); classMapping.AddReference(new ManyToOneMapping()); _mocker.Get<IHbmWriter<ManyToOneMapping>>() .Expect(x => x.Write(classMapping.References.First())) .Return(new HbmManyToOne()); _classWriter.VerifyXml(classMapping) .Element("many-to-one").Exists(); }
public void Should_write_the_properties() { var classMapping = new ClassMapping(); classMapping.AddProperty(new PropertyMapping()); _mocker.Get<IHbmWriter<PropertyMapping>>() .Expect(x => x.Write(classMapping.Properties.First())) .Return(new HbmProperty()); _classWriter.VerifyXml(classMapping) .Element("property").Exists(); }
protected virtual void BindProperties(PersistentClass model, ClassMapping mapping) { foreach (var propertyMapping in mapping.Properties) { var value = new SimpleValue(model.Table); BindSimpleValue(value, propertyMapping); BindProperty(propertyMapping, value, model); BindColumn(value, new ColumnMapping { Name = propertyMapping.Name, PropertyInfo = propertyMapping.PropertyInfo, Length=propertyMapping.Length, IsNotNullable = propertyMapping.IsNotNullable }); } foreach (var propertyMapping in mapping.Collections) { //TODO: Implement collection mapping } }
protected virtual void BindPocoRepresentation(ClassMapping classMapping, PersistentClass clazz) { string className = classMapping.Type.AssemblyQualifiedName; clazz.ClassName = className; clazz.ProxyInterfaceName = className; }
public void Should_set_the_parent_class_for_the_discriminator() { var classMap = new ClassMapping {Name = "class1" }; classMap.Discriminator = new DiscriminatorMapping(); classMap.Discriminator.ParentClass.ShouldEqual(classMap); }
public void SetUp() { _classMapping = new ClassMapping(); }
public void Add(ClassMapping mapping) { _mappings.Add(mapping); }
public override void Visit(ClassMapping classMapping) { classMapping.AcceptVisitor(this); }
public void Should_write_the_discriminator() { var classMapping = new ClassMapping {Discriminator = new DiscriminatorMapping()}; _mocker.Get<IHbmWriter<DiscriminatorMapping>>() .Expect(x => x.Write(classMapping.Discriminator)).Return(new HbmDiscriminator()); _classWriter.VerifyXml(classMapping) .Element("discriminator").Exists(); }
public virtual void ProcessClass(ClassMapping classMapping) { }
public void Should_write_the_id() { var classMapping = new ClassMapping { Id = new IdMapping() }; _mocker.Get<IHbmWriter<IIdentityMapping>>() .Expect(x => x.Write(classMapping.Id)) .Return(new HbmId()); _classWriter.VerifyXml(classMapping) .Element("id").Exists(); }