public override void establish_context()
        {
            externalComponentMapping = new ExternalComponentMapping(ComponentType.Component);
            externalComponentMapping.Set(x => x.Type, Layer.Defaults, typeof(ComponentTarget));
            var externalComponent = Stub <IExternalComponentMappingProvider> .Create(cfg =>
                                                                                     cfg.Stub(x => x.GetComponentMapping()).Return(externalComponentMapping));

            visitor = new ComponentReferenceResolutionVisitor(new [] { new ComponentMapComponentReferenceResolver() }, new[] { externalComponent });
            referenceComponentMapping = new ReferenceComponentMapping(ComponentType.Component, null, null, null, null);
        }
示例#2
0
        public override void establish_context()
        {
            external_component_mapping = new ExternalComponentMapping(ComponentType.Component)
            {
                Type = typeof(ComponentTarget)
            };
            var external_component = Stub <IExternalComponentMappingProvider> .Create(cfg =>
                                                                                      cfg.Stub(x => x.GetComponentMapping()).Return(external_component_mapping));

            visitor = new ComponentReferenceResolutionVisitor(new[] { external_component });
            reference_component_mapping = new ReferenceComponentMapping(ComponentType.Component, null, null, null, null);
        }
        public override void establish_context()
        {
            externalComponentMapping = new ExternalComponentMapping(ComponentType.Component);
            externalComponentMapping.Set(x => x.Type, Layer.Defaults, typeof(ComponentTarget));

            var externalComponent = A.Fake <IExternalComponentMappingProvider>();

            A.CallTo(() => externalComponent.GetComponentMapping()).Returns(externalComponentMapping);
            A.CallTo(() => externalComponent.Type).Returns(null);

            visitor = new ComponentReferenceResolutionVisitor(new[] { new ComponentMapComponentReferenceResolver() }, new[] { externalComponent });
            referenceComponentMapping = new ReferenceComponentMapping(ComponentType.Component, null, null, null, null);
        }
示例#4
0
        public override void establish_context()
        {
            visitor = new ComponentColumnPrefixVisitor();
            reference_with_a_prefix = new ReferenceComponentMapping(ComponentType.Component, new DummyPropertyInfo("PROPERTY", typeof(Target)).ToMember(), typeof(ComponentTarget), typeof(Target), column_prefix);
            reference_with_a_prefix.AssociateExternalMapping(new ExternalComponentMapping(ComponentType.Component));

            reference_without_a_prefix = new ReferenceComponentMapping(ComponentType.Component, new DummyPropertyInfo("PROPERTY", typeof(Target)).ToMember(), typeof(ComponentTarget), typeof(Target), null);

            var external_mapping = new ExternalComponentMapping(ComponentType.Component);

            external_mapping.AddProperty(property_with_column("propertyColumn"));

            reference_without_a_prefix.AssociateExternalMapping(external_mapping);
        }
        public override void establish_context()
        {
            var externalComponentOne = A.Fake <IExternalComponentMappingProvider>();
            {
                var externalComponentMapping = new ExternalComponentMapping(ComponentType.Component);
                externalComponentMapping.Set(x => x.Type, Layer.Defaults, typeof(ComponentTarget));
                A.CallTo(() => externalComponentOne.GetComponentMapping()).Returns(externalComponentMapping);
                A.CallTo(() => externalComponentOne.Type).Returns(typeof(ComponentTarget));
            }
            var externalComponentTwo = A.Fake <IExternalComponentMappingProvider>();

            {
                var externalComponentMapping = new ExternalComponentMapping(ComponentType.Component);
                externalComponentMapping.Set(x => x.Type, Layer.Defaults, typeof(ComponentTarget));
                A.CallTo(() => externalComponentTwo.GetComponentMapping()).Returns(externalComponentMapping);
                A.CallTo(() => externalComponentTwo.Type).Returns(typeof(ComponentTarget));
            }

            visitor        = new ComponentReferenceResolutionVisitor(new[] { new ComponentMapComponentReferenceResolver() }, new[] { externalComponentOne, externalComponentTwo });
            memberProperty = new DummyPropertyInfo("Component", typeof(ComponentTarget)).ToMember();
        }
        public override void establish_context()
        {
            var externalComponentOne = Stub <IExternalComponentMappingProvider> .Create(cfg =>
            {
                var externalComponentMapping = new ExternalComponentMapping(ComponentType.Component);
                externalComponentMapping.Set(x => x.Type, Layer.Defaults, typeof(ComponentTarget));
                cfg.Stub(x => x.GetComponentMapping()).Return(externalComponentMapping);
                cfg.Stub(x => x.Type).Return(typeof(ComponentTarget));
            });

            var externalComponentTwo = Stub <IExternalComponentMappingProvider> .Create(cfg =>
            {
                var externalComponentMapping = new ExternalComponentMapping(ComponentType.Component);
                externalComponentMapping.Set(x => x.Type, Layer.Defaults, typeof(ComponentTarget));
                cfg.Stub(x => x.GetComponentMapping()).Return(externalComponentMapping);
                cfg.Stub(x => x.Type).Return(typeof(ComponentTarget));
            });

            visitor        = new ComponentReferenceResolutionVisitor(new[] { new ComponentMapComponentReferenceResolver() }, new[] { externalComponentOne, externalComponentTwo });
            memberProperty = new DummyPropertyInfo("Component", typeof(ComponentTarget)).ToMember();
        }
        public ExternalComponentMapping Resolve(ComponentResolutionContext context, IEnumerable <IExternalComponentMappingProvider> componentProviders)
        {
            // this will only be called if there was no ComponentMap found
            var mapping = new ExternalComponentMapping(ComponentType.Component)
            {
                Member = context.ComponentMember,
                ContainingEntityType = context.EntityType,
            };

            mapping.Set(x => x.Name, Layer.Defaults, context.ComponentMember.Name);
            mapping.Set(x => x.Type, Layer.Defaults, context.ComponentType);

            if (context.ComponentMember.IsProperty && !context.ComponentMember.CanWrite)
            {
                mapping.Set(x => x.Access, Layer.Defaults, cfg.GetAccessStrategyForReadOnlyProperty(context.ComponentMember).ToString());
            }

            mapper.FlagAsMapped(context.ComponentType);
            mapper.MergeMap(context.ComponentType, mapping, new List <Member>());

            return(mapping);
        }
示例#8
0
        public override void establish_context()
        {
            parentMapping            = new ParentMapping();
            externalComponentMapping = new ExternalComponentMapping(ComponentType.Component);
            externalComponentMapping.Set(x => x.Access, Layer.Defaults, "access");
            externalComponentMapping.Set(x => x.Insert, Layer.Defaults, true);
            externalComponentMapping.Set(x => x.Lazy, Layer.Defaults, true);
            externalComponentMapping.Set(x => x.OptimisticLock, Layer.Defaults, true);
            externalComponentMapping.Set(x => x.Parent, Layer.Defaults, parentMapping);
            externalComponentMapping.Set(x => x.Unique, Layer.Defaults, true);
            externalComponentMapping.Set(x => x.Update, Layer.Defaults, true);
            externalComponentMapping.AddAny(new AnyMapping());
            externalComponentMapping.AddCollection(CollectionMapping.Bag());
            externalComponentMapping.AddComponent(new ComponentMapping(ComponentType.Component));
            externalComponentMapping.AddFilter(new FilterMapping());
            externalComponentMapping.AddOneToOne(new OneToOneMapping());
            externalComponentMapping.AddProperty(new PropertyMapping());
            externalComponentMapping.AddReference(new ManyToOneMapping());

            memberProperty            = new DummyPropertyInfo("Component", typeof(Target)).ToMember();
            referenceComponentMapping = new ReferenceComponentMapping(ComponentType.Component, memberProperty, typeof(ComponentTarget), typeof(Target), "column-prefix");
        }
示例#9
0
        public override void establish_context()
        {
            parent_mapping             = new ParentMapping();
            external_component_mapping = new ExternalComponentMapping(ComponentType.Component)
            {
                Access         = "access",
                Insert         = true,
                Lazy           = true,
                OptimisticLock = true,
                Parent         = parent_mapping,
                Unique         = true,
                Update         = true
            };
            external_component_mapping.AddAny(new AnyMapping());
            external_component_mapping.AddCollection(new BagMapping());
            external_component_mapping.AddComponent(new ComponentMapping(ComponentType.Component));
            external_component_mapping.AddFilter(new FilterMapping());
            external_component_mapping.AddOneToOne(new OneToOneMapping());
            external_component_mapping.AddProperty(new PropertyMapping());
            external_component_mapping.AddReference(new ManyToOneMapping());

            member_property             = new DummyPropertyInfo("Component", typeof(Target)).ToMember();
            reference_component_mapping = new ReferenceComponentMapping(ComponentType.Component, member_property, typeof(ComponentTarget), typeof(Target), "column-prefix");
        }