public void WhenSetTypeByIUserVersionTypeThenSetTypeName()
{
var member = typeof(MyClass).GetProperty("Version");
var mapping = new HbmVersion();
var mapper = new VersionMapper(member, mapping);
mapper.Type <MyVerionType>();
mapping.type.Should().Contain("MyVerionType");
}
public void WhenSetTypeByIVersionTypeThenSetTypeName()
{
var member = typeof(MyClass).GetProperty("Version");
var mapping = new HbmVersion();
var mapper = new VersionMapper(member, mapping);
mapper.Type((IVersionType)NHibernateUtil.Int32);
mapping.type.Should().Be.EqualTo("Int32");
}
public void WhenSetAccessorByTypeThenCheckCompatibility()
{
var member = typeof(MyClass).GetProperty("ReadOnly");
var mapping = new HbmVersion();
var mapper = new VersionMapper(member, mapping);
Executing.This(() => mapper.Access(typeof(object))).Should().Throw <ArgumentOutOfRangeException>();
Executing.This(() => mapper.Access(typeof(FieldAccessor))).Should().NotThrow();
mapping.access.Should().Be.EqualTo(typeof(FieldAccessor).AssemblyQualifiedName);
}
public void WhenSetMultiColumnsValuesThenAutoassignColumnNames()
{
var member = typeof(MyClass).GetProperty("Version");
var mapping = new HbmVersion();
var mapper = new VersionMapper(member, mapping);
mapper.Columns(cm => cm.Length(50), cm => cm.SqlType("VARCHAR(10)"));
mapping.Columns.Should().Have.Count.EqualTo(2);
mapping.Columns.All(cm => cm.name.Satisfy(n => !string.IsNullOrEmpty(n)));
}
public void WhenSetDefaultColumnNameThenDoesNotSetTheName()
{
var member = typeof(MyClass).GetProperty("Version");
var mapping = new HbmVersion();
var mapper = new VersionMapper(member, mapping);
mapper.Column(cm => cm.Name("Version"));
mapping.column1.Should().Be.Null();
mapping.Columns.Should().Be.Empty();
}
public void Version(MemberInfo versionProperty, Action <IVersionMapper> versionMapping)
{
if (versionMapper == null)
{
var hbmVersion = new HbmVersion();
classMapping.Item1 = hbmVersion;
versionMapper = new VersionMapper(versionProperty, hbmVersion);
}
versionMapping(versionMapper);
}
public void WhenSetDifferentColumnNameThenSetTheName()
{
var member = typeof(MyClass).GetProperty("Version");
var mapping = new HbmVersion();
var mapper = new VersionMapper(member, mapping);
mapper.Column(cm => cm.Name("pepe"));
mapping.Columns.Should().Have.Count.EqualTo(1);
mapping.Columns.Single().name.Should().Be("pepe");
}
public void CanSetUsavedValue()
{
var member = typeof(MyClass).GetProperty("Version");
var mapping = new HbmVersion();
var mapper = new VersionMapper(member, mapping);
mapper.UnsavedValue(null);
mapping.unsavedvalue.Should().Be("null");
mapper.UnsavedValue(0);
mapping.unsavedvalue.Should().Be("0");
}
public void CanSetInsert()
{
var member = typeof(MyClass).GetProperty("Version");
var mapping = new HbmVersion();
var mapper = new VersionMapper(member, mapping);
mapper.Insert(true);
mapping.insertSpecified.Should("True is the default value (not specified if true)").Be.False();
mapper.Insert(false);
mapping.insert.Should().Be.False();
mapping.insertSpecified.Should().Be.True();
}
public void WhenSetColumnValuesThenAddColumnTag()
{
var member = typeof(MyClass).GetProperty("Version");
var mapping = new HbmVersion();
var mapper = new VersionMapper(member, mapping);
mapper.Column(cm =>
{
cm.SqlType("timestamp");
cm.NotNullable(true);
});
mapping.Columns.Should().Not.Be.Null();
mapping.Columns.Should().Have.Count.EqualTo(1);
}
public VersionMapper(MemberInfo member, HbmVersion hbmVersion)
{
if (member == null)
{
throw new ArgumentNullException("member");
}
if (hbmVersion == null)
{
throw new ArgumentNullException("hbmVersion");
}
this.member = member;
versionMapping = hbmVersion;
versionMapping.name = member.Name;
entityPropertyMapper = new AccessorPropertyMapper(member.DeclaringType, member.Name, x => versionMapping.access = x);
}
private void BindColumns(HbmVersion versionSchema, SimpleValue model, bool isNullable, string propertyPath)
{
Table table = model.Table;
if (versionSchema.column1 != null)
{
var col = new Column {
Value = model
};
BindColumn(col, isNullable);
col.Name = mappings.NamingStrategy.ColumnName(versionSchema.column1);
if (table != null)
{
table.AddColumn(col);
}
model.AddColumn(col);
}
else if (versionSchema.column != null)
{
foreach (HbmColumn hbmColumn in versionSchema.column)
{
var col = new Column {
Value = model
};
BindColumn(hbmColumn, col, isNullable);
if (table != null)
{
table.AddColumn(col);
}
model.AddColumn(col);
}
}
if (model.ColumnSpan == 0)
{
var col = new Column {
Value = model
};
BindColumn(col, isNullable);
col.Name = mappings.NamingStrategy.PropertyToColumnName(propertyPath);
model.Table.AddColumn(col);
model.AddColumn(col);
}
}
public void WhenSetMultiColumnsValuesThenAddColumns()
{
var member = typeof(MyClass).GetProperty("Version");
var mapping = new HbmVersion();
var mapper = new VersionMapper(member, mapping);
mapper.Type <MyVerionType>();
mapper.Columns(cm =>
{
cm.Name("column1");
cm.Length(50);
}, cm =>
{
cm.Name("column2");
cm.SqlType("VARCHAR(10)");
});
mapping.Columns.Should().Have.Count.EqualTo(2);
}
private void BindProperty(HbmVersion versionSchema, Property property, IDictionary <string, MetaAttribute> inheritedMetas)
{
property.Name = versionSchema.name;
if (property.Value.Type == null)
{
throw new MappingException("could not determine a property type for: " + property.Name);
}
property.PropertyAccessorName = versionSchema.access ?? mappings.DefaultAccess;
property.Cascade = mappings.DefaultCascade;
property.IsUpdateable = true;
property.IsInsertable = true;
property.IsOptimisticLocked = true;
property.Generation = Convert(versionSchema.generated);
if (property.Generation == PropertyGeneration.Always ||
property.Generation == PropertyGeneration.Insert)
{
// generated properties can *never* be insertable...
if (property.IsInsertable)
{
// insertable simply because that is the user did not specify
// anything; just override it
property.IsInsertable = false;
}
// properties generated on update can never be updateable...
if (property.IsUpdateable && property.Generation == PropertyGeneration.Always)
{
// updateable only because the user did not specify
// anything; just override it
property.IsUpdateable = false;
}
}
property.MetaAttributes = GetMetas(versionSchema, inheritedMetas);
LogMappedProperty(property);
}
private void BindVersion(HbmVersion versionSchema, PersistentClass rootClass, Table table, IDictionary <string, MetaAttribute> inheritedMetas)
{
if (versionSchema == null)
{
return;
}
string propertyName = versionSchema.name;
var simpleValue = new SimpleValue(table);
new TypeBinder(simpleValue, Mappings).Bind(versionSchema.type);
new ColumnsBinder(simpleValue, Mappings).Bind(versionSchema.Columns, false,
() =>
new HbmColumn
{
name = mappings.NamingStrategy.PropertyToColumnName(propertyName)
});
if (!simpleValue.IsTypeSpecified)
{
simpleValue.TypeName = NHibernateUtil.Int32.Name;
}
var property = new Property(simpleValue);
BindProperty(versionSchema, property, inheritedMetas);
// for version properties marked as being generated, make sure they are "always"
// generated; "insert" is invalid. This is dis-allowed by the schema, but just to make
// sure...
if (property.Generation == PropertyGeneration.Insert)
{
throw new MappingException("'generated' attribute cannot be 'insert' for versioning property");
}
simpleValue.NullValue = versionSchema.unsavedvalue;
rootClass.Version = property;
rootClass.AddProperty(property);
}
