public void ComposingPatternsAppliersPacks() { // Thanks to Lorenzo Vegetti to provide the domain of this example. // This example refers to a little-domain, interesting from the point of view of mapping with ConfORM. // Here you can see how apply general convetion, how and when compose patterns-appliers-packs and patterns-appliers, // how ConfORM can apply different mapping depending on the type of enum (see the difference on CostOptions) and so on... // You don't have to organize the mapping all in one class, as in this example, and you don't have to use the IModuleMapping... // You can organize the mapping as you feel more confortable for your application; in some case a class is enough, in other cases would // be better the separation per module/concern, you are not closed in "mapping per class" box. var orm = new ObjectRelationalMapper(); // With the follow line I'm adding the pattern for the POID strategy ("native" instead the default "High-Low") orm.Patterns.PoidStrategies.Add(new NativePoidPattern()); // composition of patterns-appliers-packs and patterns-appliers for Lorenzo's domain // Note: for bidirectional-one-to-many association Lorenzo is not interested in the default cascade behavior, // implemented in the BidirectionalOneToManyRelationPack, because he is using a sort of soft-delete in his base class VersionModelBase. // He can implements a custom pack of patterns-appliers to manage the situation when classes does not inherits from VersionModelBase by the way // he don't want the cascade atall, so the BidirectionalOneToManyInverseApplier will be enough IPatternsAppliersHolder patternsAppliers = (new SafePropertyAccessorPack()) .Merge(new OneToOneRelationPack(orm)) .Merge(new BidirectionalManyToManyRelationPack(orm)) .Merge(new DiscriminatorValueAsClassNamePack(orm)) .Merge(new CoolColumnsNamingPack(orm)) .Merge(new TablePerClassPack()) .Merge(new PluralizedTablesPack(orm, new EnglishInflector())) .Merge(new ListIndexAsPropertyPosColumnNameApplier()) .Merge(new BidirectionalOneToManyInverseApplier(orm)) .Merge(new EnumAsStringPack()) .Merge(new DatePropertyByNameApplier()) .Merge(new MsSQL2008DateTimeApplier()); // Instancing the Mapper using the result of Merge var mapper = new Mapper(orm, patternsAppliers); // Setting the version property using the base class orm.VersionProperty<VersionModelBase>(v => v.Version); // Note: I'm declaring the strategy only for the base entity orm.TablePerClassHierarchy<Cost>(); orm.TablePerClass<EditionQuotation>(); orm.TablePerClass<ProductQuotation>(); orm.TablePerClass<Quotation>(); AppliesGeneralConventions(mapper); // EditionQuotation.PrintCost don't use lazy-loading mapper.Customize<EditionQuotation>(map => map.ManyToOne(eq => eq.PrintCost, m2o => m2o.Lazy(LazyRelation.NoLazy))); // Customizes some others DDL's stuff outside conventions CustomizeColumns(mapper); // Note : I have to create mappings for the whole domain HbmMapping mapping = mapper.CompileMappingFor( typeof (GenericModelBase<>).Assembly.GetTypes().Where(t => t.Namespace == typeof (GenericModelBase<>).Namespace)); Console.Write(mapping.AsString()); }
public HbmMapping CreateMapping() { var orm = new ObjectRelationalMapper(); //主键生成策略(自增) orm.Patterns.PoidStrategies.Add(new NativePoidPattern()); var entities = new[] { typeof(User), typeof(PlusMaterial), typeof(StockIn), typeof(StockInDetail), typeof(StockOut), typeof(StockOutDetail), }; orm.TablePerClass(entities); //关系映射 orm.ManyToOne<StockInDetail, StockIn>(); orm.ManyToOne<StockOutDetail, StockOut>(); //数据库命名规则 var mapper = new Mapper(orm, new CoolPatternsAppliersHolder(orm)); orm.TablePerClass(entities); var hc = mapper.CompileMappingFor(Assembly.Load("PMMS.Entities").GetTypes()); return hc; }
public void DefiningAndCustomizingVersionThroughBaseImplementation() { // In this example I'll show how you can work with Version and how ConfORM understands OOP var orm = new ObjectRelationalMapper(); var mapper = new Mapper(orm, new CoolPatternsAppliersHolder(orm)); // In this case I will use the definition of table-to-class strategy class by class orm.TablePerClass<CurrencyDefinition>(); orm.TablePerClass<Company>(); orm.TablePerClass<Customer>(); orm.TablePerClass<Provider>(); // Defining relations orm.OneToOne<Company, Customer>(); orm.OneToOne<Company, Provider>(); // In the follow line I'm defining which is the property used as Version for all classes inherited from VersionedEntity orm.VersionProperty<VersionedEntity>(ve=> ve.Version); // In the follow line I'm customizing the column-name for the property used as Version for all classes inherited from VersionedEntity.... // Note : VersionedEntity is not an entity, it is only a base class. mapper.Class<VersionedEntity>(cm => cm.Version(ve => ve.Version, vm => vm.Column("Revision"))); // In the follow line I'm customizing the column-name for the property used as Version only for the class Provider // Note : You can move the follow line before the previous and the result does not change, this is because ConfORM can understand // which is a base customization and which is the specific customization. mapper.Class<Provider>(cm => cm.Version(ve => ve.Version, vm => vm.Column("IncrementalVersion"))); // Note : I have to create mappings for the whole domain; Entity and VersionedEntity are excluded from de mapping because out-side // root-entities hierarchy (root-entities are : CurrencyDefinition, Company, Customer, Provider) var mapping = mapper.CompileMappingFor(typeof(Entity).Assembly.GetTypes().Where(t => t.Namespace == typeof(Entity).Namespace)); Console.Write(mapping.AsString()); }
public void WhenNotRegisteredAsManyToOneRecognizeRelation() { var mapper = new ObjectRelationalMapper(); mapper.TablePerClass<AEntity>(); mapper.TablePerClass<BEntity>(); mapper.IsOneToMany(typeof(BEntity), typeof(AEntity)).Should().Be.True(); mapper.IsManyToOne(typeof(AEntity), typeof(BEntity)).Should().Be.True(); }
public void WhenExplicitRegisteredRecognizeInverseRelation() { var mapper = new ObjectRelationalMapper(); mapper.TablePerClass<AEntity>(); mapper.TablePerClass<BEntity>(); mapper.ManyToOne<AEntity, BEntity>(); mapper.IsOneToMany(typeof(BEntity), typeof(AEntity)).Should().Be.True(); }
public void WhenExplicitRegisteredRecognizeInverseRelationAsImplicit() { var mapper = new ObjectRelationalMapper(); mapper.TablePerClass<User>(); mapper.TablePerClass<Person>(); mapper.OneToOne<User, Person>(); mapper.IsMasterOneToOne(typeof(Person), typeof(User)).Should().Be.False(); }
public void WhenExplicitRegisteredRecognizeRelation() { var mapper = new ObjectRelationalMapper(); mapper.TablePerClass<User>(); mapper.TablePerClass<Person>(); mapper.OneToOne<User, Person>(); mapper.IsOneToOne(typeof(User), typeof(Person)).Should().Be.True(); }
public void RecognizeOneToMany() { var orm = new ObjectRelationalMapper(); orm.TablePerClass<Parent>(); orm.TablePerClass<Image>(); orm.IsOneToMany(typeof (Child), typeof (Image)).Should().Be.True(); }
public void CanDiscoverManyToOneFromComponentToEntity() { var orm = new ObjectRelationalMapper(); orm.TablePerClass<AEntity>(); orm.TablePerClass<BEntity>(); orm.Component<AComponent>(); orm.IsManyToOne(typeof(AComponent), typeof(BEntity)).Should().Be.True(); }
public void WhenFindInterfaceForRootClassThenRecognizeRelation() { var orm = new ObjectRelationalMapper(); orm.TablePerClass<Contact>(); orm.TablePerClass<UserGroup>(); orm.ManyToOne<UserGroup, ISecurity>(); orm.IsManyToOne(typeof (UserGroup), typeof (ISecurity)).Should().Be.True(); }
public void IntegrationWithObjectRelationalMapper() { var orm = new ObjectRelationalMapper(); orm.TablePerClass<Parent>(); orm.TablePerClass<Child>(); orm.ManyToOne<Child, Parent>(); HbmMapping mapping = GetMapping(orm); VerifyMapping(mapping); }
public void CanDiscoverManyToOneFromComponentToEntity() { var orm = new ObjectRelationalMapper(); orm.TablePerClass <AEntity>(); orm.TablePerClass <BEntity>(); orm.Component <AComponent>(); orm.IsManyToOne(typeof(AComponent), typeof(BEntity)).Should().Be.True(); }
public void IntegrationWithObjectRelationalMapper() { var orm = new ObjectRelationalMapper(); orm.TablePerClass<AEntity>(); orm.TablePerClass<BEntity>(); orm.ManyToOne<AEntity, BEntity>(); HbmMapping mapping = GetMapping(orm); VerifyAEntityMapping(mapping); }
public void DomainDefinition(ObjectRelationalMapper orm) { orm.TablePerClass<Animal>(); orm.TablePerClass<User>(); orm.TablePerClass<StateProvince>(); orm.TablePerClassHierarchy<Zoo>(); orm.ManyToMany<Human, Human>(); orm.OneToOne<User, Human>(); }
public void IntegrationWithObjectRelationalMapper() { var orm = new ObjectRelationalMapper(); orm.TablePerClass<Person>(); orm.TablePerClass<Animal>(); orm.ManyToMany<Person, Animal>(); HbmMapping mapping = GetMapping(orm); VerifyMapping(mapping); }
public void WithoutExplicitCascade() { var orm = new ObjectRelationalMapper(); orm.TablePerClass <Parent>(); orm.TablePerClass <Child>(); orm.ManyToOne <Child, Parent>(); HbmMapping mapping = GetMapping(orm); VerifyMapping(mapping); }
public void WhenExplicitRegisteredAsOneToOneNotRecognizeRelation() { var mapper = new ObjectRelationalMapper(); mapper.TablePerClass<AEntity>(); mapper.TablePerClass<BEntity>(); mapper.OneToOne<AEntity, BEntity>(); mapper.IsOneToMany(typeof(BEntity), typeof(AEntity)).Should().Be.False(); // the default behaviour map an unidirectional one-to-one as a many-to-one (for NHibernate) // mapper.IsManyToOne(typeof(AEntity), typeof(BEntity)).Should().Be.False(); }
public void WhenNullThenNoThrow() { var orm = new ObjectRelationalMapper(); orm.TablePerClass <Parent>(); orm.TablePerClass <Child>(); var pattern = new PolymorphismBidirectionalOneToManyMemberPattern(orm); pattern.Executing(p => p.Match(null)).NotThrows(); }
public void IntegrationWithObjectRelationalMapper() { var orm = new ObjectRelationalMapper(); orm.TablePerClass <Parent>(); orm.TablePerClass <Child>(); orm.ManyToOne <Child, Parent>(); HbmMapping mapping = GetMapping(orm); VerifyMapping(mapping); }
public void IntegrationWithObjectRelationalMapper() { var orm = new ObjectRelationalMapper(); orm.TablePerClass<AEntity>(); orm.TablePerClass<BEntity>(); orm.ManyToOne<AEntity, BEntity>(); orm.Cascade<AEntity, BEntity>(Cascade.Persist | Cascade.Remove); HbmMapping mapping = GetMapping(orm); VerifyMappingWithCascade(mapping); }
public void IntegrationWithObjectRelationalMapper() { var orm = new ObjectRelationalMapper(); orm.TablePerClass <AEntity>(); orm.TablePerClass <BEntity>(); orm.ManyToOne <AEntity, BEntity>(); HbmMapping mapping = GetMapping(orm); VerifyAEntityMapping(mapping); }
public void WhenTheDomainDoesNotContainMoreImplsThenNoMatch() { var orm = new ObjectRelationalMapper(); orm.TablePerClass <MyEntity>(); orm.TablePerClass <MyRelatedRoot1>(); var pattern = new PolymorphismBidirectionalAnyToManyPattern(orm); pattern.Match(ForClass <MyRelatedRoot1> .Property(x => x.Items)).Should().Be.False(); }
public void WhenInterfaceOnChildThenMatch() { var orm = new ObjectRelationalMapper(); orm.TablePerClass <Parent>(); orm.TablePerClass <Child>(); var pattern = new PolymorphismBidirectionalOneToManyMemberPattern(orm); pattern.Match(ForClass <Parent> .Property(x => x.Children)).Should().Be.True(); }
public void WhenManySideIsNotAnEntityThenNoMatch() { var orm = new ObjectRelationalMapper(); orm.TablePerClass <MyRelatedRoot1>(); orm.TablePerClass <MyRelatedRoot2>(); var pattern = new PolymorphismBidirectionalAnyToManyPattern(orm); pattern.Match(ForClass <MyRelatedRoot1> .Property(x => x.Items)).Should().Be.False(); }
public void WhenNoGenericThenNoMatch() { var orm = new ObjectRelationalMapper(); orm.TablePerClass <Parent>(); orm.TablePerClass <Child>(); var pattern = new PolymorphismBidirectionalOneToManyMemberPattern(orm); pattern.Match(ForClass <Parent> .Property(x => x.Whatever)).Should().Be.False(); }
public void IntegrationWithObjectRelationalMapper() { var orm = new ObjectRelationalMapper(); orm.TablePerClass <Person>(); orm.TablePerClass <Animal>(); orm.ManyToMany <Person, Animal>(); HbmMapping mapping = GetMapping(orm); VerifyMapping(mapping); }
public void WhenExplicitRegisteredAsOneToOneNotRecognizeRelation() { var mapper = new ObjectRelationalMapper(); mapper.TablePerClass <AEntity>(); mapper.TablePerClass <BEntity>(); mapper.OneToOne <AEntity, BEntity>(); mapper.IsOneToMany(typeof(BEntity), typeof(AEntity)).Should().Be.False(); // the default behaviour map an unidirectional one-to-one as a many-to-one (for NHibernate) // mapper.IsManyToOne(typeof(AEntity), typeof(BEntity)).Should().Be.False(); }
public void WhenNoPolymorphicThenNoMatch() { // using the concrete implementation of IDomainInspector this test is more like an integration-test but it is exactly what I need. var orm = new ObjectRelationalMapper(); orm.TablePerClass <Parent>(); orm.TablePerClass <Child>(); var pattern = new PolymorphismBidirectionalOneToManyMemberPattern(orm); pattern.Match(ForClass <Parent> .Property(x => x.Children)).Should().Be.False(); }
public void WhenDefineRootEntityThenRegister() { var orm = new ObjectRelationalMapper(); orm.TablePerClass<MyClass>(); orm.TablePerClass<Related>(); orm.NaturalId<MyClass>(x => x.Name, x => x.Related, x => x.MyComponent, x => x.Any); orm.IsMemberOfNaturalId(ForClass<MyClass>.Property(x => x.Name)).Should().Be.True(); orm.IsMemberOfNaturalId(ForClass<MyClass>.Property(x => x.Related)).Should().Be.True(); orm.IsMemberOfNaturalId(ForClass<MyClass>.Property(x => x.MyComponent)).Should().Be.True(); orm.IsMemberOfNaturalId(ForClass<MyClass>.Property(x => x.Any)).Should().Be.True(); }
private HbmMapping GetMapping() { var orm = new ObjectRelationalMapper(); orm.TablePerClass <MyEntity>(); orm.TablePerClass <MyRelatedRoot1>(); orm.TablePerClass <MyRelatedRoot2>(); var mapper = new Mapper(orm); return(mapper.CompileMappingFor(new[] { typeof(MyEntity), typeof(MyRelatedRoot1), typeof(MyRelatedRoot2) })); }
public void WhenInterfaceOnChildAndPropertyExclusionOnInterfaceThenNoMatch() { var orm = new ObjectRelationalMapper(); orm.TablePerClass <Parent>(); orm.TablePerClass <Child>(); orm.ExcludeProperty <IChild>(c => c.Parent); var pattern = new PolymorphismBidirectionalOneToManyMemberPattern(orm); pattern.Match(ForClass <Parent> .Property(x => x.Children)).Should().Be.False(); }
public void WithExplicitCascadeToAll() { var orm = new ObjectRelationalMapper(); orm.TablePerClass <Parent>(); orm.TablePerClass <Child>(); orm.ManyToOne <Child, Parent>(); orm.Cascade <Parent, Child>(CascadeOn.All | CascadeOn.DeleteOrphans); HbmMapping mapping = GetMapping(orm); VerifyMapping(mapping); }
public void WhenDefineWithNullThenRegisterValid() { var orm = new ObjectRelationalMapper(); orm.TablePerClass<MyClass>(); orm.TablePerClass<Related>(); orm.NaturalId<MyClass>(x => x.Name, null, x => x.MyComponent, null); orm.IsMemberOfNaturalId(ForClass<MyClass>.Property(x => x.Name)).Should().Be.True(); orm.IsMemberOfNaturalId(ForClass<MyClass>.Property(x => x.Related)).Should().Be.False(); orm.IsMemberOfNaturalId(ForClass<MyClass>.Property(x => x.MyComponent)).Should().Be.True(); orm.IsMemberOfNaturalId(ForClass<MyClass>.Property(x => x.Any)).Should().Be.False(); }
public void IntegrationWithObjectRelationalMapper() { var orm = new ObjectRelationalMapper(); orm.TablePerClass <AEntity>(); orm.TablePerClass <BEntity>(); orm.ManyToOne <AEntity, BEntity>(); orm.Cascade <AEntity, BEntity>(Cascade.Persist | Cascade.Remove); HbmMapping mapping = GetMapping(orm); VerifyMappingWithCascade(mapping); }
public void WhenManyToManyShouldNotMatch() { var orm = new ObjectRelationalMapper(); orm.TablePerClass <Contact>(); orm.TablePerClass <Company>(); orm.ManyToMany <Contact, Company>(); var pattern = new PolymorphismBidirectionalOneToManyMemberPattern(orm); MemberInfo memberInfo = ForClass <Contact> .Property(x => x.Companies); pattern.Match(memberInfo).Should().Be.False(); }
public void WhenDefineWithNullThenRegisterValid() { var orm = new ObjectRelationalMapper(); orm.TablePerClass <MyClass>(); orm.TablePerClass <Related>(); orm.NaturalId <MyClass>(x => x.Name, null, x => x.MyComponent, null); orm.IsMemberOfNaturalId(ForClass <MyClass> .Property(x => x.Name)).Should().Be.True(); orm.IsMemberOfNaturalId(ForClass <MyClass> .Property(x => x.Related)).Should().Be.False(); orm.IsMemberOfNaturalId(ForClass <MyClass> .Property(x => x.MyComponent)).Should().Be.True(); orm.IsMemberOfNaturalId(ForClass <MyClass> .Property(x => x.Any)).Should().Be.False(); }
public void WhenDefineRootEntityThenRegister() { var orm = new ObjectRelationalMapper(); orm.TablePerClass <MyClass>(); orm.TablePerClass <Related>(); orm.NaturalId <MyClass>(x => x.Name, x => x.Related, x => x.MyComponent, x => x.Any); orm.IsMemberOfNaturalId(ForClass <MyClass> .Property(x => x.Name)).Should().Be.True(); orm.IsMemberOfNaturalId(ForClass <MyClass> .Property(x => x.Related)).Should().Be.True(); orm.IsMemberOfNaturalId(ForClass <MyClass> .Property(x => x.MyComponent)).Should().Be.True(); orm.IsMemberOfNaturalId(ForClass <MyClass> .Property(x => x.Any)).Should().Be.True(); }
public void WhenExplicitlyDeclaredThenEachCollectionMapToItsCorrectParentPropertyIntegration() { var orm = new ObjectRelationalMapper(); orm.TablePerClass <Team>(); orm.TablePerClass <Match>(); orm.Bidirectional <Team, Match>(t => t.MatchesAtHome, m => m.HomeTeam); orm.Bidirectional <Match, Team>(m => m.RoadTeam, t => t.MatchesOnRoad); HbmMapping mapping = GetMapping(orm); VerifyBagsHasTheCorrectKey(mapping); }
public void WhenAnyToManyThenNoMatch() { var orm = new ObjectRelationalMapper(); orm.TablePerClass <MyEntity>(); orm.TablePerClass <MyRelatedRoot1>(); orm.TablePerClass <MyRelatedRoot2>(); var applier = new OneToManyKeyColumnApplier(orm); applier.Match(new PropertyPath(null, ForClass <MyRelatedRoot1> .Property(x => x.Items))).Should().Be.False(); applier.Match(new PropertyPath(null, ForClass <MyRelatedRoot2> .Property(x => x.Items))).Should().Be.False(); }
public void WhenOrmCascadeIsAllThenApplyOndeleteCascade() { var orm = new ObjectRelationalMapper(); orm.TablePerClass<Parent>(); orm.TablePerClass<Child>(); orm.ManyToOne<Child, Parent>(); orm.Cascade<Parent, Child>(Cascade.All); HbmMapping mapping = GetMapping(orm); HbmClass rc = mapping.RootClasses.First(r => r.Name.Contains("Parent")); var relation = rc.Properties.First(p => p.Name == "Children"); var collection = (HbmBag)relation; collection.Key.ondelete.Should().Be(HbmOndelete.Cascade); }
public void WhenOrmCascadeDoesNotIncludeDeleteNorDeleteOrhphanThenNotApplyOndeleteCascade() { var orm = new ObjectRelationalMapper(); orm.TablePerClass<Parent>(); orm.TablePerClass<Child>(); orm.ManyToOne<Child, Parent>(); orm.Cascade<Parent, Child>(Cascade.Persist | Cascade.ReAttach); HbmMapping mapping = GetMapping(orm); HbmClass rc = mapping.RootClasses.First(r => r.Name.Contains("Parent")); var relation = rc.Properties.First(p => p.Name == "Children"); var collection = (HbmBag)relation; collection.Key.ondelete.Should().Be(HbmOndelete.Noaction); }
public void WhenExplicitManyToManyThenShouldMapSimpleRelationAsManyToOneByDefault() { var orm = new ObjectRelationalMapper(); orm.TablePerClass<User>(); orm.TablePerClass<Group>(); orm.ManyToMany<Group, User>(); orm.IsManyToOne(typeof(Group), typeof(User)).Should().Be.True(); orm.IsManyToMany(typeof(Group), typeof(User)).Should().Be.True(); orm.IsOneToMany(typeof(Group), typeof(User)).Should().Be.False(); orm.IsOneToOne(typeof(Group), typeof(User)).Should().Be.False(); orm.IsManyToMany(typeof(User), typeof(Group)).Should().Be.True(); orm.IsOneToMany(typeof(User), typeof(Group)).Should().Be.False(); }
public void WhenInterfaceIsImplementedByEntityThenApplyInverse() { var orm = new ObjectRelationalMapper(); orm.TablePerClass <Parent>(); orm.TablePerClass <Child>(); var mapper = new Mapper(orm); var mapping = mapper.CompileMappingFor(new[] { typeof(Parent) }); var hbmClass = mapping.RootClasses.Single(x => x.Name == "Parent"); var hbmBag = (HbmBag)hbmClass.Properties.Single(x => x.Name == "Children"); hbmBag.Inverse.Should().Be.True(); }
public void WhenInterfaceIsImplementedByEntityThenApplyCascade() { var orm = new ObjectRelationalMapper(); orm.TablePerClass <Parent>(); orm.TablePerClass <Child>(); var mapper = new Mapper(orm); var mapping = mapper.CompileMappingFor(new[] { typeof(Parent) }); var hbmClass = mapping.RootClasses.Single(x => x.Name == "Parent"); var hbmBag = (HbmBag)hbmClass.Properties.Single(x => x.Name == "Children"); hbmBag.Cascade.Should().Contain("all").And.Contain("delete-orphan"); }
public void WhenManyToManyIsNotManyToOne() { var mapper = new ObjectRelationalMapper(); mapper.TablePerClass<AEntity>(); mapper.TablePerClass<BEntity>(); mapper.ManyToMany<AEntity, BEntity>(); mapper.IsOneToMany(typeof(AEntity), typeof(BEntity)).Should().Be.False(); mapper.IsOneToMany(typeof(BEntity), typeof(AEntity)).Should().Be.False(); // Commented because CfgORM-5 // many-to-many should work only inside a collection. // many-to-one should work only outside a collection. //mapper.IsManyToOne(typeof(AEntity), typeof(BEntity)).Should().Be.False(); //mapper.IsManyToOne(typeof(BEntity), typeof(AEntity)).Should().Be.False(); }
public void WhenTheDomainContainsMoreImplsThenMatch() { var orm = new ObjectRelationalMapper(); orm.TablePerClass <MyEntity>(); orm.TablePerClass <MyRoot1>(); orm.TablePerClass <MyRelatedRoot2>(); orm.AddToDomain(typeof(MyRelatedNoRoot1)); var pattern = new PolymorphismBidirectionalAnyToManyPattern(orm); pattern.Match(ForClass <MyRelatedNoRoot1> .Property(x => x.Items)).Should().Be.True(); pattern.Match(ForClass <MyRelatedRoot2> .Property(x => x.Items)).Should().Be.True(); }
public void WhenExplicitManyToManyThenShouldMapSimpleRelationAsManyToOneByDefault() { var orm = new ObjectRelationalMapper(); orm.TablePerClass <User>(); orm.TablePerClass <Group>(); orm.ManyToMany <Group, User>(); orm.IsManyToOne(typeof(Group), typeof(User)).Should().Be.True(); orm.IsManyToMany(typeof(Group), typeof(User)).Should().Be.True(); orm.IsOneToMany(typeof(Group), typeof(User)).Should().Be.False(); orm.IsOneToOne(typeof(Group), typeof(User)).Should().Be.False(); orm.IsManyToMany(typeof(User), typeof(Group)).Should().Be.True(); orm.IsOneToMany(typeof(User), typeof(Group)).Should().Be.False(); }
public void WhenInterfaceIsImplementedByEntityThenRecognizeOneToMany() { var orm = new ObjectRelationalMapper(); orm.TablePerClass <MyEntity>(); orm.TablePerClass <MyRelation>(); orm.TablePerClass <MyRelation1>(); var mapper = new Mapper(orm); var mapping = mapper.CompileMappingFor(new[] { typeof(MyEntity) }); HbmClass rc = mapping.RootClasses.First(r => r.Name.Contains("MyEntity")); var hbmBagOfIRelation = (HbmBag)rc.Properties.Where(p => p.Name == "Relations").Single(); hbmBagOfIRelation.ElementRelationship.Should().Be.InstanceOf <HbmOneToMany>(); }
public void IntegrationWithObjectRelationalMapper() { var orm = new ObjectRelationalMapper(); orm.TablePerClass<AEntity>(); orm.TablePerClass<BEntity>(); orm.OneToOne<AEntity, BEntity>(); orm.Cascade<AEntity, BEntity>(Cascade.Persist | Cascade.Remove); HbmMapping mapping = GetMapping(orm); // the default behaviour map an unidirectional one-to-one as a many-to-one (for NHibernate) 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"); }
private static HbmMapping GetMapping() { var orm = new ObjectRelationalMapper(); var mapper = new Mapper(orm, new CoolPatternsAppliersHolder(orm)); orm.TablePerClassHierarchy<Product>(); orm.TablePerClass<ActorRole>(); orm.Patterns.PoidStrategies.Add( new GuidOptimizedPoidPattern()); orm.VersionProperty<Entity>(x => x.Version); orm.NaturalId<Product>(p => p.Name); orm.Cascade<Movie, ActorRole>( Cascade.All | Cascade.DeleteOrphans); mapper.AddPropertyPattern(mi => mi.GetPropertyOrFieldType() == typeof(Decimal) && mi.Name.Contains("Price"), pm => pm.Type(NHibernateUtil.Currency)); mapper.AddPropertyPattern(mi => orm.IsRootEntity(mi.DeclaringType) && !"Description".Equals(mi.Name), pm => pm.NotNullable(true)); mapper.Subclass<Movie>(cm => cm.List(movie => movie.Actors, colm => colm.Index( lim => lim.Column("ActorIndex")), m => { })); var domainClasses = typeof(Entity).Assembly.GetTypes() .Where(t => typeof(Entity).IsAssignableFrom(t)); return mapper.CompileMappingFor(domainClasses); }
public void WhenOrmCascadeIsAllThenApplyOndeleteCascade() { var orm = new ObjectRelationalMapper(); orm.TablePerClass <Parent>(); orm.TablePerClass <Child>(); orm.ManyToOne <Child, Parent>(); orm.Cascade <Parent, Child>(CascadeOn.All); HbmMapping mapping = GetMapping(orm); HbmClass rc = mapping.RootClasses.First(r => r.Name.Contains("Parent")); var relation = rc.Properties.First(p => p.Name == "Children"); var collection = (HbmBag)relation; collection.Key.ondelete.Should().Be(HbmOndelete.Cascade); }
public void WhenOrmCascadeDoesNotIncludeDeleteNorDeleteOrhphanThenNotApplyOndeleteCascade() { var orm = new ObjectRelationalMapper(); orm.TablePerClass <Parent>(); orm.TablePerClass <Child>(); orm.ManyToOne <Child, Parent>(); orm.Cascade <Parent, Child>(CascadeOn.Persist | CascadeOn.ReAttach); HbmMapping mapping = GetMapping(orm); HbmClass rc = mapping.RootClasses.First(r => r.Name.Contains("Parent")); var relation = rc.Properties.First(p => p.Name == "Children"); var collection = (HbmBag)relation; collection.Key.ondelete.Should().Be(HbmOndelete.Noaction); }
public void ComposingPatternsAppliersPacksUsingInflector() { // In this example you can see how use the inflector adding some special class name translation. var orm = new ObjectRelationalMapper(); // Creation of inflector adding some special class name translation var inflector = new SpanishInflector(); AddCustomData_Dictionary(inflector); IPatternsAppliersHolder patternsAppliers = (new SafePropertyAccessorPack()) .Merge(new OneToOneRelationPack(orm)) .Merge(new BidirectionalManyToManyRelationPack(orm)) .Merge(new BidirectionalOneToManyRelationPack(orm)) .Merge(new DiscriminatorValueAsClassNamePack(orm)) .Merge(new CoolColumnsNamingPack(orm)) .Merge(new TablePerClassPack()) .Merge(new PluralizedTablesPack(orm, inflector)) // <=== .Merge(new ListIndexAsPropertyPosColumnNameApplier()); // Instancing the Mapper using the result of Merge var mapper = new Mapper(orm, patternsAppliers); orm.TablePerClass <UsuarioWeb>(); var mapping = mapper.CompileMappingFor(new[] { typeof(UsuarioWeb) }); Console.Write(mapping.AsString()); }
public void WhenCustomizePropertyOnInterfaceThenApplyCustomizationOnImplementations() { var orm = new ObjectRelationalMapper(); orm.TablePerClass<MyClass1>(); orm.TablePerClass<MyClass2>(); var mapper = new Mapper(orm); mapper.Customize<IHasMessage>(x=> x.Property(hasMessage=> hasMessage.Message, pm=> pm.Length(123))); var mappings = mapper.CompileMappingFor(new[] { typeof(MyClass1), typeof(MyClass2) }); HbmClass hbmMyClass1 = mappings.RootClasses.Single(hbm => hbm.Name == "MyClass1"); hbmMyClass1.Properties.OfType<HbmProperty>().Where(p=> p.Name == "Message").Single().length.Should().Be("123"); HbmClass hbmMyClass2 = mappings.RootClasses.Single(hbm => hbm.Name == "MyClass2"); hbmMyClass2.Properties.OfType<HbmProperty>().Where(p => p.Name == "Message").Single().length.Should().Be("123"); }
public void ComposingPatternsAppliersPacksUsingInflector() { // In this example I'll use the same domain, but composing others packs, changing the strategy for the hierarchy var orm = new ObjectRelationalMapper(); // The follow line show how compose patterns-appliers-packs and patterns-appliers IPatternsAppliersHolder patternsAppliers = (new SafePropertyAccessorPack()) .Merge(new OneToOneRelationPack(orm)) .Merge(new BidirectionalManyToManyRelationPack(orm)) .Merge(new BidirectionalOneToManyRelationPack(orm)) .Merge(new DiscriminatorValueAsClassNamePack(orm)) .Merge(new CoolColumnsNamingPack(orm)) .Merge(new TablePerClassPack()) .Merge(new PluralizedTablesPack(orm, new EnglishInflector())) .Merge(new ListIndexAsPropertyPosColumnNameApplier()) .Merge(new DatePropertyByNameApplier()) .Merge(new MsSQL2008DateTimeApplier()); // Instancing the Mapper using the result of Merge var mapper = new Mapper(orm, patternsAppliers); // Note: I'm declaring the strategy only for the base entity orm.TablePerClass<Animal>(); // Note : I have to create mappings for the whole domain var mapping = mapper.CompileMappingFor(typeof(Animal).Assembly.GetTypes().Where(t => t.Namespace == typeof(Animal).Namespace)); Console.Write(mapping.AsString()); }
public void ComposingPatternsAppliersPacksUsingInflector() { // In this example I'll use the same domain, but composing others packs, changing the strategy for the hierarchy var orm = new ObjectRelationalMapper(); // The follow line show how compose patterns-appliers-packs and patterns-appliers IPatternsAppliersHolder patternsAppliers = (new SafePropertyAccessorPack()) .Merge(new OneToOneRelationPack(orm)) .Merge(new BidirectionalManyToManyRelationPack(orm)) .Merge(new BidirectionalOneToManyRelationPack(orm)) .Merge(new DiscriminatorValueAsClassNamePack(orm)) .Merge(new CoolColumnsNamingPack(orm)) .Merge(new TablePerClassPack()) .Merge(new PluralizedTablesPack(orm, new EnglishInflector())) .Merge(new ListIndexAsPropertyPosColumnNameApplier()) .Merge(new DatePropertyByNameApplier()) .Merge(new MsSQL2008DateTimeApplier()); // Instancing the Mapper using the result of Merge var mapper = new Mapper(orm, patternsAppliers); // Note: I'm declaring the strategy only for the base entity orm.TablePerClass <Animal>(); // Note : I have to create mappings for the whole domain var mapping = mapper.CompileMappingFor(typeof(Animal).Assembly.GetTypes().Where(t => t.Namespace == typeof(Animal).Namespace)); Console.Write(mapping.AsString()); }
public void RegisteringComponentAndEntityThrow() { var mapper = new ObjectRelationalMapper(); mapper.Component<AComponent>(); ActionAssert.Throws(() => mapper.TablePerClass<AComponent>()).Should().Be.InstanceOf<MappingException>(); ActionAssert.Throws(() => mapper.TablePerConcreteClass<AComponent>()).Should().Be.InstanceOf<MappingException>(); ActionAssert.Throws(() => mapper.TablePerClassHierarchy<AComponent>()).Should().Be.InstanceOf<MappingException>(); }
public void IntegrationWithObjectRelationalMapper() { var orm = new ObjectRelationalMapper(); orm.TablePerClass<Node>(); HbmMapping mapping = GetMapping(orm); VerifyMapping(mapping); }
public void WhenRegisterPersistentPropertyOnInterfaceThenShouldRecognizePropertyOfConcreteImpl() { var orm = new ObjectRelationalMapper(); orm.TablePerClass<Person>(); orm.PersistentProperty<IEntity>(p => p.IsValid); orm.IsPersistentProperty(ForClass<Person>.Property(p => p.IsValid)).Should().Be.True(); }
public void WhenRegisterExclusionPropertyOnInterfaceThenShouldExcludePropertyOfConcreteImpl() { var orm = new ObjectRelationalMapper(); orm.TablePerClass<Person>(); orm.ExcludeProperty<IEntity>(p => p.Something); orm.IsPersistentProperty(ForClass<Person>.Property(p => p.Something)).Should().Be.False(); }