public void ShouldAllowConventionsToAlterBiDirectionalTableNames()
{
var model = new PersistenceModel();
var leftMap = new ClassMap<Left>();
leftMap.Id(x => x.Id);
leftMap.HasManyToMany(x => x.Rights);
var rightMap = new ClassMap<Right>();
rightMap.Id(x => x.Id);
rightMap.HasManyToMany(x => x.Lefts);
model.Add(leftMap);
model.Add(rightMap);
model.Conventions.Add<TestTableNameConvention>();
var mappings = model.BuildMappings();
var leftMapping = mappings.SelectMany(x => x.Classes).Where(x => x.Type == typeof(Left)).First();
var rightMapping = mappings.SelectMany(x => x.Classes).Where(x => x.Type == typeof(Right)).First();
leftMapping.Collections.First().TableName.ShouldEqual("Lefts_Rights");
rightMapping.Collections.First().TableName.ShouldEqual("Lefts_Rights");
}
public void ShouldHaveSameTableNameForBothSidesOfMappingWhenRightSpecified()
{
var model = new PersistenceModel();
var leftMap = new ClassMap<Left>();
leftMap.Id(x => x.Id);
leftMap.HasManyToMany(x => x.Rights);
var rightMap = new ClassMap<Right>();
rightMap.Id(x => x.Id);
rightMap.HasManyToMany(x => x.Lefts)
.Table("MyJoinTable");
model.Add(leftMap);
model.Add(rightMap);
var mappings = model.BuildMappings();
var leftMapping = mappings.SelectMany(x => x.Classes).Where(x => x.Type == typeof(Left)).First();
var rightMapping = mappings.SelectMany(x => x.Classes).Where(x => x.Type == typeof(Right)).First();
leftMapping.Collections.First().TableName.ShouldEqual("MyJoinTable");
rightMapping.Collections.First().TableName.ShouldEqual("MyJoinTable");
}
public void CreatePersistenceModel()
{
conventionFinder = MockRepository.GenerateMock<IConventionFinder>();
model = new PersistenceModel(conventionFinder);
cfg = Fluently.Configure()
.Database(SQLiteConfiguration.Standard.InMemory)
.BuildConfiguration();
}
public void CreatePersistenceModel()
{
conventionFinder = MockRepository.GenerateMock<IConventionFinder>();
model = new PersistenceModel(conventionFinder);
TempDir = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
RemoveArtifacts();
Directory.CreateDirectory(TempDir);
}
private string render_xml(Action<PersistenceModel> addMappings)
{
var model = new PersistenceModel();
addMappings(model);
var mappings = model.BuildMappings();
var doc = new MappingXmlSerializer().Serialize(mappings.First());
return doc.OuterXml;
}
public override void establish_context()
{
var component_map = new ComponentMap<Component>();
component_map.Map(x => x.Property);
var class_map = new ClassMap<Target>();
class_map.Component(x => x.Component);
persistence_model = new PersistenceModel();
persistence_model.Add(class_map);
persistence_model.Add(component_map);
}
public void ShouldntDuplicateJoinMapping()
{
var model = new PersistenceModel();
var classMap = new ClassMap<Target>();
classMap.Id(x => x.Id);
classMap.Join("other", m => m.Map(x => x.Property));
model.Add(classMap);
model.Configure(cfg);
cfg.ClassMappings.First()
.JoinClosureIterator.Count().ShouldEqual(1);
}
public override void establish_context()
{
model = new PersistenceModel();
var comp_map = new ComponentMap<ComponentTarget>();
comp_map.Map(x => x.Property);
model.Add(comp_map);
var map = new ClassMap<Target>();
map.Id(x => x.Id);
map.Component(x => x.Component)
.ColumnPrefix(column_prefix);
model.Add(map);
}
public void ShouldAllowOverridingOfDefaultInConventions()
{
var model = new PersistenceModel();
var map = new ClassMap<IdentityExamples>();
map.Id(x => x.Int);
model.Conventions.Add(new IdConvention());
model.Add(map);
var @class = model.BuildMappings()
.First()
.Classes.First();
((IdMapping)@class.Id).Generator.Class.ShouldEqual("increment");
}
public void SetUp()
{
PersistenceModel model = new PersistenceModel();
model.Conventions.Add(new BackfieldAccessConvention());
model.Add(new CompositeIdModelMapping());
model.Add(new ManyToManyModelMapping());
model.Add(new ManyToOneModelMapping());
model.Add(new OneToOneModelMapping());
model.Add(new ParentModelMapping());
var classMappings = model.BuildMappings().SelectMany(x => x.Classes).ToDictionary(x => x.Type);
compositeId = classMappings[typeof(CompositeIdModel)];
manyToMany = classMappings[typeof(ManyToManyModel)];
manyToOne = classMappings[typeof(ManyToOneModel)];
oneToOne = classMappings[typeof(OneToOneModel)];
parent = classMappings[typeof(ParentModel)];
}
public void ShouldAllowSettingOfKeyInConvention()
{
var model = new PersistenceModel();
var parent = new ClassMap<Parent>();
var child = new SubclassMap<Child>();
model.Add(parent);
model.Add(child);
model.Conventions.Add<SCKeyConvention>();
var subclass = model.BuildMappings()
.SelectMany(x => x.Classes)
.First()
.Subclasses.First();
((JoinedSubclassMapping)subclass).Key.Columns.First().Name.ShouldEqual("xxx");
((JoinedSubclassMapping)subclass).Key.Columns.Count().ShouldEqual(1);
}
public void ComponentWithPropertiesShouldAddToModelComponentsCollection()
{
var classMap = new ClassMap<Parent>();
classMap.Id(x => x.Id);
var subclassMap = new SubclassMap<Child>();
subclassMap.Component(x => x.Component, c => c.Map(x => x.Name));
var model = new PersistenceModel();
model.Add(classMap);
model.Add(subclassMap);
model.BuildMappings()
.First()
.Classes.First()
.Subclasses.First()
.Components.Count().ShouldEqual(1);
}
public void SetUp()
{
var cfg = MsSqlConfiguration.MsSql2005
.ShowSql()
.ConnectionString.Is("Server=(local);initial catalog=nhibernate;Integrated Security=SSPI")
.ShowSql()
.ConfigureProperties(new Configuration());
var mappings = cfg.CreateMappings();
var dialect = new SQLiteDialect();
var model = new PersistenceModel();
model.Add(new PersonMap());
model.AddConvention(new NamingConvention());
var hibernateMapping = model.BuildHibernateMapping();
var classBinder = new RootClassBinder(mappings, dialect);
foreach (var mapping in hibernateMapping.Classes)
{
classBinder.Bind(mapping);
}
cfg.BuildMapping();
schemaExport = new SchemaExport(cfg);
}
public IntegrationTestHelper()
{
PersistenceModel = new PersistenceModel();
PersistenceModel.AddConvention(new NamingConvention());
}
internal FluentMappingsContainer()
{
model = new PersistenceModel();
}
public MappingTester(PersistenceModel model)
{
this.model = model;
this.model.ValidationEnabled = false;
}
public override void establish_context()
{
model = new PersistenceModel();
var componentMap = new ComponentMap<FieldComponent>();
componentMap.Map(x => x.X);
componentMap.Map(x => x.Y);
model.Add(componentMap);
var classMapping = new ClassMap<Root>();
classMapping.Id(r => r.Id);
classMapping.Component(Reveal.Member<Root, FieldComponent>("component"), cpt => cpt.Access.Field().ColumnPrefix(columnPrefix));
model.Add(classMapping);
}
public void CreatePersistenceModel()
{
model = new PersistenceModel();
model.Conventions.Add <TestForeignKeyConvention>();
}
void IConfigurationModifier.Configure(PersistenceModel model)
{
_modelModifications.Each(m => m(model));
}
public void AddCalculation(PersistenceModel calculation)
{
_CalculationsDbContext.Calculations.Add(calculation);
_CalculationsDbContext.SaveChanges(true);
}
public SingleConnectionSessionSourceForSQLiteInMemoryTesting(IDictionary <string, string> properties, PersistenceModel model) : base(properties, model)
{
}
public void CreatePersistenceModel()
{
model = new PersistenceModel();
model.Conventions.Add<TestForeignKeyConvention>();
}
private string Where(string where)
{
var classMap = new ClassMap<Target>();
classMap.Id(x => x.Id);
classMap.HasMany(x => x.Children)
.Where(where);
var model = new PersistenceModel();
model.Add(classMap);
return model.BuildMappings()
.First()
.Classes.First()
.Collections.First()
.Where;
}
public SingleConnectionSessionSourceForSQLiteInMemoryTesting(IDictionary<string, string> properties, PersistenceModel model) : base(properties, model)
{
}
public MappingConfiguration UsePersistenceModel(PersistenceModel persistenceModel)
{
model = persistenceModel;
return(this);
}
public void CreatePersistenceModel()
{
model = new PersistenceModel();
}
public void ShouldHaveSameTableNameForUniDirectionalMapping()
{
var model = new PersistenceModel();
var leftMap = new ClassMap<Left>();
leftMap.Id(x => x.Id);
leftMap.HasManyToMany(x => x.Rights);
var rightMap = new ClassMap<Right>();
rightMap.Id(x => x.Id);
model.Add(leftMap);
model.Add(rightMap);
var mappings = model.BuildMappings();
var leftMapping = mappings.SelectMany(x => x.Classes).Where(x => x.Type == typeof(Left)).First();
leftMapping.Collections.First().TableName.ShouldEqual("RightToLeft");
}
static ChatController()
{
_persistenceModel = Db.For <PersistenceModel>(); // get an "database"
}
public void MergeOutputShouldSetFlagOnFluentPersistenceModelsOnApply()
{
var model = new PersistenceModel();
mapping.UsePersistenceModel(model);
mapping.MergeMappings();
mapping.Apply(new Configuration());
model.MergeMappings.ShouldBeTrue();
}
public void ShouldHaveSameTableNameForBothSidesOfMappingWhenHasMultipleBiDirectionalManyToManysOnSameEntities()
{
var model = new PersistenceModel();
var leftMap = new ClassMap<Left>();
leftMap.Id(x => x.Id);
leftMap.HasManyToMany(x => x.Rights);
leftMap.HasManyToMany(x => x.SecondRights);
var rightMap = new ClassMap<Right>();
rightMap.Id(x => x.Id);
rightMap.HasManyToMany(x => x.Lefts);
rightMap.HasManyToMany(x => x.SecondLefts);
model.Add(leftMap);
model.Add(rightMap);
var mappings = model.BuildMappings();
var leftMapping = mappings.SelectMany(x => x.Classes).Where(x => x.Type == typeof(Left)).First();
var rightMapping = mappings.SelectMany(x => x.Classes).Where(x => x.Type == typeof(Right)).First();
leftMapping.Collections.First().TableName.ShouldEqual("LeftsToRights");
rightMapping.Collections.First().TableName.ShouldEqual("LeftsToRights");
leftMapping.Collections.ElementAt(1).TableName.ShouldEqual("SecondLeftsToSecondRights");
rightMapping.Collections.ElementAt(1).TableName.ShouldEqual("SecondLeftsToSecondRights");
}
public MappingConfiguration UsePersistenceModel(PersistenceModel persistenceModel)
{
model = persistenceModel;
return this;
}
public void CreatePersistenceModel()
{
conventionFinder = MockRepository.GenerateMock<IConventionFinder>();
model = new PersistenceModel(conventionFinder);
}
public void CreatePersistenceModel()
{
model = new PersistenceModel();
}
public MappingConfiguration(IDiagnosticLogger logger)
{
_model = new PersistenceModel();
FluentMappings = new FluentMappingsContainer();
}
