public void ShouldWriteManyToManyForManyToManyMapping()
{
var mapping = new ManyToManyMapping();
writer.VerifyXml(mapping)
.RootElement.HasName("many-to-many");
}
public void Should_generate_valid_hbm()
{
var manyToMany = new ManyToManyMapping {ClassName = "Class1"};
var writer = new HbmManyToManyWriter();
writer.ShouldGenerateValidOutput(manyToMany);
}
public override void ProcessManyToMany(ManyToManyMapping manyToManyMapping)
{
if (!manyToManyMapping.Attributes.IsSpecified(x => x.ClassName))
{
if (manyToManyMapping.ChildType == null)
throw new ConventionException("Cannot apply the naming convention. No type specified.", manyToManyMapping);
manyToManyMapping.ClassName = DetermineNameFromType(manyToManyMapping.ChildType);
}
}
public void ShouldWriteColumns()
{
var container = new XmlWriterContainer();
var mapping = new ManyToManyMapping();
mapping.AddColumn(new ColumnMapping { Name = "Column1" });
writer = container.Resolve<IXmlWriter<ManyToManyMapping>>();
writer.VerifyXml(mapping)
.Element("column").Exists();
}
public void Should_write_many_to_many()
{
var manyToMany = new ManyToManyMapping();
var manyTomanyWriter = MockRepository.GenerateStub<IHbmWriter<ManyToManyMapping>>();
manyTomanyWriter.Expect(x => x.Write(manyToMany)).Return(new HbmManyToMany());
var writer = new HbmCollectionContentsWriter(null, manyTomanyWriter);
object result = writer.Write(manyToMany);
result.ShouldBeOfType(typeof(HbmManyToMany));
}
private ICollectionRelationshipMapping CreateManyToMany(PropertyInfo property, Type child, Type parent)
{
var mapping = new ManyToManyMapping
{
Class = new TypeReference(property.PropertyType.GetGenericArguments()[0]),
ContainingEntityType = parent
};
mapping.AddDefaultColumn(new ColumnMapping { Name = child.Name + "_id" });
return mapping;
}
static ICollectionRelationshipMapping CreateManyToMany(Member member, Type parentType, Type childType)
{
var columnMapping = new ColumnMapping();
columnMapping.Set(x => x.Name, Layer.Defaults, childType.Name + "Id");
var mapping = new ManyToManyMapping { ContainingEntityType = parentType };
mapping.Set(x => x.Class, Layer.Defaults, new TypeReference(childType));
mapping.Set(x => x.ParentType, Layer.Defaults, parentType);
mapping.Set(x => x.ChildType, Layer.Defaults, childType);
mapping.AddColumn(Layer.Defaults, columnMapping);
return mapping;
}
private static ICollectionRelationshipMapping CreateManyToMany(Member member, Type parentType, Type childType)
{
var ColumnMapping = new ColumnMapping();
ColumnMapping.Set(x => x.Name, Layer.Defaults, "Id_" + childType.Name);
var Mapping = new ManyToManyMapping {ContainingEntityType = parentType};
Mapping.Set(x => x.Class, Layer.Defaults, new FluentNHibernate.MappingModel.TypeReference(childType));
Mapping.Set(x => x.ParentType, Layer.Defaults, parentType);
Mapping.Set(x => x.ChildType, Layer.Defaults, childType);
Mapping.AddColumn(Layer.Defaults, ColumnMapping);
return Mapping;
}
public bool Equals(ManyToManyMapping other)
{
if (ReferenceEquals(null, other))
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return(Equals(other.attributes, attributes) &&
other.columns.ContentEquals(columns) &&
Equals(other.ContainingEntityType, ContainingEntityType));
}
static ICollectionRelationshipMapping CreateManyToMany(Member property, Type child, Type parent)
{
var mapping = new ManyToManyMapping
{
ContainingEntityType = parent
};
mapping.Set(x => x.Class, Layer.Defaults, new TypeReference(property.PropertyType.GetGenericArguments()[0]));
var columnMapping = new ColumnMapping();
columnMapping.Set(x => x.Name, Layer.Defaults, child.Name + "_id");
mapping.AddColumn(Layer.Defaults, columnMapping);
return mapping;
}
public ManyToManyInspector(ManyToManyMapping mapping)
{
this.mapping = mapping;
mappedProperties.Map(x => x.LazyLoad, x => x.Lazy);
}
public void CreateDsl()
{
mapping = new ManyToManyMapping();
inspector = new ManyToManyInspector(mapping);
}
public virtual void Visit(ManyToManyMapping mapping)
{
}
public virtual void ProcessManyToMany(ManyToManyMapping manyToManyMapping)
{
}
public void Should_apply_to_many_to_many_mapping()
{
var manyToManyMapping = new ManyToManyMapping();
manyToManyMapping.ChildType = typeof (Album);
_namingConvention.ProcessManyToMany(manyToManyMapping);
manyToManyMapping.ClassName.ShouldEqual(manyToManyMapping.ChildType.AssemblyQualifiedName);
}
public ManyToManyInstance(ManyToManyMapping mapping)
: base(mapping)
{
this.mapping = mapping;
}
