public void CanSetConstrained()
		{
			var hbm = new HbmOneToOne();
			var mapper = new OneToOneMapper(null, hbm);
			mapper.Constrained(true);
			Assert.That(hbm.constrained, Is.True);
		}
		public void AssignCascadeStyle()
		{
			var hbm = new HbmOneToOne();
			var mapper = new OneToOneMapper(null, hbm);
			mapper.Cascade(Mapping.ByCode.Cascade.Persist | Mapping.ByCode.Cascade.Remove);
			Assert.That(hbm.cascade.Split(',').Select(w => w.Trim()), Contains.Item("persist").And.Contains("delete"));
		}
 public void AssignCascadeStyle()
 {
     var hbm = new HbmOneToOne();
     var mapper = new OneToOneMapper(null, hbm);
     mapper.Cascade(Cascade.Persist | Cascade.Remove);
     hbm.cascade.Split(',').Select(w=> w.Trim()).Should().Contain("persist").And.Contain("delete");
 }
		public void AutoCleanUnsupportedCascadeStyle()
		{
			var hbm = new HbmOneToOne();
			var mapper = new OneToOneMapper(null, hbm);
			mapper.Cascade(Mapping.ByCode.Cascade.Persist | Mapping.ByCode.Cascade.DeleteOrphans | Mapping.ByCode.Cascade.Remove);
			hbm.cascade.Split(',').Select(w => w.Trim()).All(w => w.Satisfy(cascade => !cascade.Contains("orphan")));
		}
		public void CanSetConstrained()
		{
			var hbm = new HbmOneToOne();
			var mapper = new OneToOneMapper(null, hbm);
			mapper.Constrained(true);
			hbm.constrained.Should().Be.True();
		}
		public virtual void OneToOne(MemberInfo property, Action<IOneToOneMapper> mapping)
		{
			var hbm = new HbmOneToOne {name = property.Name};
			var type = typeof(OneToOneMapper<>).MakeGenericType(property.GetPropertyOrFieldType());
			var mapper = (IOneToOneMapper)Activator.CreateInstance(type, property, hbm);
			mapping(mapper);
			AddProperty(hbm);
		}
		public void CanSetLazyness()
		{
			var hbm = new HbmOneToOne();
			var mapper = new OneToOneMapper(null, hbm);
			mapper.Lazy(LazyRelation.NoProxy);
			Assert.That(hbm.Lazy, Is.Not.Null);
			Assert.That(hbm.Lazy, Is.EqualTo(HbmLaziness.NoProxy));
		}
		public void WhenNoMemberPropertyRefAcceptAnything()
		{
			var hbm = new HbmOneToOne();
			var mapper = new OneToOneMapper(null, hbm);
			mapper.PropertyReference(typeof(Array).GetProperty("Length"));

			hbm.propertyref.Should().Be("Length");
		}
		public void CanSetForeignKeyName()
		{
			var hbm = new HbmOneToOne();
			var mapper = new OneToOneMapper(null, hbm);
			mapper.ForeignKey("Id");

			Assert.That(hbm.foreignkey, Is.EqualTo("Id"));
		}
		public void WhenNullMemberPropertyRefNull()
		{
			var hbm = new HbmOneToOne();
			var mapper = new OneToOneMapper(null, hbm);
			mapper.PropertyReference(null);

			hbm.propertyref.Should().Be.Null();
		}
		public void WhenNoMemberPropertyRefAcceptAnything()
		{
			var hbm = new HbmOneToOne();
			var mapper = new OneToOneMapper(null, hbm);
			mapper.PropertyReference(typeof(Array).GetProperty("Length"));

			Assert.That(hbm.propertyref, Is.EqualTo("Length"));
		}
		public void WhenForeignKeyIsNullForeignKeyMappingIsNull()
		{
			var hbm = new HbmOneToOne();
			var mapper = new OneToOneMapper(null, hbm);
			mapper.ForeignKey(null);

			Assert.That(hbm.foreignkey, Is.Null);
		}
		public void WhenForeignKeyIsNullForeignKeyMappingIsNull()
		{
			var hbm = new HbmOneToOne();
			var mapper = new OneToOneMapper(null, hbm);
			mapper.ForeignKey(null);

			hbm.foreignkey.Should().Be.Null();
		}
		public void CanSetForeignKeyName()
		{
			var hbm = new HbmOneToOne();
			var mapper = new OneToOneMapper(null, hbm);
			mapper.ForeignKey("Id");

			hbm.foreignkey.Should().Be("Id");
		}
		public void CanSetLazyness()
		{
			var hbm = new HbmOneToOne();
			var mapper = new OneToOneMapper(null, hbm);
			mapper.Lazy(LazyRelation.NoProxy);
			hbm.Lazy.Should().Have.Value();
			hbm.Lazy.Should().Be(HbmLaziness.NoProxy);
		}
		public void CanSetAccessor()
		{
			var member = typeof(MyClass).GetProperty("Relation");
			var hbm = new HbmOneToOne();
			var mapper = new OneToOneMapper(member, hbm);

			mapper.Access(Accessor.ReadOnly);
			Assert.That(hbm.Access, Is.EqualTo("readonly"));
		}
        public void CanSetFormula()
        {
            var member = ForClass<MyClass>.Property(c => c.Relation);
            var mapping = new HbmOneToOne();
            var mapper = new OneToOneMapper(member, mapping);

            mapper.Formula("SomeFormula");
            mapping.formula1.Should().Be("SomeFormula");
        }
		public void CanSetAccessor()
		{
			var member = typeof(MyClass).GetProperty("Relation");
			var hbm = new HbmOneToOne();
			var mapper = new OneToOneMapper(member, hbm);

			mapper.Access(Accessor.ReadOnly);
			hbm.Access.Should().Be("readonly");
		}
        public void WhenMemberPropertyRefAcceptOnlyMemberOfExpectedType()
        {
            var hbm = new HbmOneToOne();
            var mapper = new OneToOneMapper(typeof(MyClass).GetProperty("Relation"), hbm);
            mapper.PropertyReference(typeof(Relation).GetProperty("Whatever"));

            hbm.propertyref.Should().Be("Whatever");

            ActionAssert.Throws<ArgumentOutOfRangeException>(() => mapper.PropertyReference(typeof(Array).GetProperty("Length")));
        }
Example #20
0
		public OneToOneMapper(MemberInfo member, IAccessorPropertyMapper accessorMapper, HbmOneToOne oneToOne)
		{
			this.member = member;
			this.oneToOne = oneToOne;
			if (member == null)
			{
				this.oneToOne.access = "none";
			}
			entityPropertyMapper = member == null ? new NoMemberPropertyMapper() : accessorMapper;
		}
Example #21
0
		public OneToOneMapper(MemberInfo member, HbmOneToOne oneToOne)
		{
			this.member = member;
			this.oneToOne = oneToOne;
			if (member == null)
			{
				this.oneToOne.access = "none";
			}
			if (member == null)
			{
				entityPropertyMapper = new NoMemberPropertyMapper();
			}
			else
			{
				entityPropertyMapper = new AccessorPropertyMapper(member.DeclaringType, member.Name, x => oneToOne.access = x);
			}
		}
		public void WhenSetFormulaWithMultipleLinesThenSetFormulaNode()
		{
			var member = For<MyClass>.Property(c => c.Relation);
			var mapping = new HbmOneToOne();
			var mapper = new OneToOneMapper(member, mapping);
			var formula = @"Line1
Line2";
			mapper.Formula(formula);
			Assert.That(mapping.formula1, Is.Null);
			var hbmFormula = mapping.formula.First();
			Assert.That(hbmFormula.Text.Length, Is.EqualTo(2));
			Assert.That(hbmFormula.Text[0], Is.EqualTo("Line1"));
			Assert.That(hbmFormula.Text[1], Is.EqualTo("Line2"));
			Assert.That(mapping.formula1, Is.Null);
		}
Example #23
0
		public OneToOneMapper(MemberInfo member, HbmOneToOne oneToOne)
			: this(member, new AccessorPropertyMapper(member.DeclaringType, member.Name, x => oneToOne.access = x), oneToOne) {}
		protected void BindOneToOne(HbmOneToOne oneToOneMapping, OneToOne model)
		{
			model.IsConstrained = oneToOneMapping.constrained;

			model.ForeignKeyType = oneToOneMapping.constrained
			                       	? ForeignKeyDirection.ForeignKeyFromParent
			                       	: ForeignKeyDirection.ForeignKeyToParent;

			InitOuterJoinFetchSetting(oneToOneMapping, model);
			InitLaziness(oneToOneMapping.Lazy, model, true);
			BindForeignKey(oneToOneMapping.foreignkey, model);

			model.ReferencedPropertyName = oneToOneMapping.propertyref;

			model.ReferencedEntityName = GetEntityName(oneToOneMapping, mappings);
			model.PropertyName = oneToOneMapping.Name;
		}
		protected void InitOuterJoinFetchSetting(HbmOneToOne oneToOne, OneToOne model)
		{
			FetchMode fetchStyle;
			bool lazy = true;

			if (!oneToOne.fetchSpecified)
			{
				if (!oneToOne.outerjoinSpecified)
				{
					//NOTE SPECIAL CASE:
					// one-to-one constrained=falase cannot be proxied,
					// so default to join and non-lazy
					lazy = model.IsConstrained;
					fetchStyle = lazy ? FetchMode.Default : FetchMode.Join;
				}
				else
				{
					fetchStyle = GetFetchStyle(oneToOne.outerjoin);
				}
			}
			else
			{
				fetchStyle = GetFetchStyle(oneToOne.fetch);
			}

			model.FetchMode = fetchStyle;
			model.IsLazy = lazy;
		}
Example #26
0
		private void BindOneToOneProperty(HbmOneToOne oneToOneMapping, Property property)
		{
			property.Cascade = oneToOneMapping.cascade ?? mappings.DefaultCascade;
			var toOne = property.Value as ToOne;
			if (toOne != null)
			{
				string propertyRef = toOne.ReferencedPropertyName;
				if (propertyRef != null)
					mappings.AddUniquePropertyReference(toOne.ReferencedEntityName, propertyRef);
				toOne.CreateForeignKey();
			}
		}
		public void WhenNullMemberPropertyRefNull()
		{
			var hbm = new HbmOneToOne();
			var mapper = new OneToOneMapper(null, hbm);
			mapper.PropertyReference(null);

			Assert.That(hbm.propertyref, Is.Null);
		}
		public void WhenMemberPropertyRefAcceptOnlyMemberOfExpectedType()
		{
			var hbm = new HbmOneToOne();
			var mapper = new OneToOneMapper(typeof(MyClass).GetProperty("Relation"), hbm);
			mapper.PropertyReference(typeof(Relation).GetProperty("Whatever"));

			Assert.That(hbm.propertyref, Is.EqualTo("Whatever"));

			Assert.That(() => mapper.PropertyReference(typeof(Array).GetProperty("Length")), Throws.TypeOf<ArgumentOutOfRangeException>());
		}
		public void CanSetFormula()
		{
			var member = For<MyClass>.Property(c => c.Relation);
			var mapping = new HbmOneToOne();
			var mapper = new OneToOneMapper(member, mapping);

			mapper.Formula("SomeFormula");
			Assert.That(mapping.formula1, Is.EqualTo("SomeFormula"));
		}
		public void WhenSetFormulaWithNullThenSetFormulaWithNull()
		{
			var member = For<MyClass>.Property(c => c.Relation);
			var mapping = new HbmOneToOne();
			var mapper = new OneToOneMapper(member, mapping);
			mapper.Formula(null);
			Assert.That(mapping.formula, Is.Null);
			Assert.That(mapping.formula1, Is.Null);
		}