public void Test_GetOwningPropName_WhenNeitherHaveProps_WhenOwnerGTRelated_ShouldReturnRevRelNameID()
{
//---------------Set up test pack-------------------
var ownerType = MockRepository.GenerateMock<FakeTypeWrapper>();
var relatedType = MockRepository.GenerateMock<FakeTypeWrapper>();
var reverseRelName = GetRandomString();
var relationshipName = GetRandomString();
string owningFKPropName = relationshipName + "ID";
string relatedFKPropName = reverseRelName + "ID";
PropertyWrapper propertyWrapper = MockRepository.GenerateStub<FakePropertyWrapper>();
SetupMockPropWrapper(propertyWrapper, ownerType, relatedType, relationshipName, reverseRelName);
ownerType.SetName("zzzzz");
relatedType.SetName("aaaa");
OneToOneAutoMapper autoMapper = new OneToOneAutoMapper(propertyWrapper);
//---------------Assert Precondition----------------
Assert.IsFalse(ownerType.HasProperty(owningFKPropName));
Assert.IsFalse(relatedType.HasProperty(relatedFKPropName));
Assert.AreEqual(1, ownerType.Name.CompareTo(relatedType.Name));
AssertMockPropSetupCorrectly(propertyWrapper, ownerType, relatedType, relationshipName, reverseRelName);
//---------------Execute Test ----------------------
var relatedPropName = autoMapper.GetOwningPropName();
//---------------Test Result -----------------------
Assert.AreEqual(owningFKPropName, relatedPropName);
}
public void Test_GetOwningPropName_OwnerHasProp_RelatedNotHasProp_ShouldReturnRelatedTypePkName()
{
//---------------Set up test pack-------------------
TypeWrapper ownerType; TypeWrapper relatedType;
string relatedFKPropName; string owningFKPropName;
var propertyWrapper
= GetPropertyWrapper(out ownerType, out relatedType, out relatedFKPropName, out owningFKPropName);
//SetupMockPropWrapper(propertyWrapper, ownerType, relatedType, relationshipName, reverseRelName);
ownerType.SetHasProperty(owningFKPropName, true);
OneToOneAutoMapper autoMapper = new OneToOneAutoMapper(propertyWrapper);
//---------------Assert Precondition----------------
Assert.IsTrue(ownerType.HasProperty(owningFKPropName));
Assert.IsFalse(relatedType.HasProperty(relatedFKPropName));
//Assert.AreEqual(reverseRelName, propertyWrapper.GetSingleReverseRelationshipName<AutoMapOneToOne>());
Assert.AreSame(ownerType, propertyWrapper.DeclaringType);
Assert.AreSame(relatedType, propertyWrapper.RelatedClassType);
// Assert.AreEqual(relationshipName, propertyWrapper.Name);
//---------------Execute Test ----------------------
var relatedPropName = autoMapper.GetOwningPropName();
//---------------Test Result -----------------------
Assert.AreEqual(owningFKPropName, relatedPropName);
}
public void Test_GetOwningPropName_OwnerHasProp_RelatedHasProp_NonStandardNaming_ShouldReturnFoundRelName()
{
//---------------Set up test pack-------------------
SetNonDefaultNamingConvention();
TypeWrapper ownerType; TypeWrapper relatedType;
string relatedFKPropName; string owningFKPropName;
var propertyWrapper
= GetPropertyWrapper(out ownerType, out relatedType, out relatedFKPropName, out owningFKPropName);
ownerType.SetHasProperty(owningFKPropName, true);
relatedType.SetHasProperty(relatedFKPropName, true);
OneToOneAutoMapper autoMapper = new OneToOneAutoMapper(propertyWrapper);
//---------------Assert Precondition----------------
Assert.IsTrue(ownerType.HasProperty(owningFKPropName));
Assert.IsTrue(relatedType.HasProperty(relatedFKPropName));
// Assert.AreNotEqual(relationshipName, relatedType.Name);
// AssertMockPropSetupCorrectly(propertyWrapper, ownerType, relatedType, relationshipName, reverseRelName);
//---------------Execute Test ----------------------
var relatedPropName = autoMapper.GetOwningPropName();
//---------------Test Result -----------------------
Assert.AreEqual(owningFKPropName, relatedPropName);
}
public void Test_GetRelatedPropName_OwnerNotHasProp_RelatedHasProp_ShouldReturnFoundRelName()
{
//---------------Set up test pack-------------------
TypeWrapper ownerType; TypeWrapper relatedType;
string relatedFKPropName; string owningFKPropName;
var propertyWrapper
= GetPropertyWrapper(out ownerType, out relatedType, out relatedFKPropName, out owningFKPropName);
relatedType.SetHasProperty(relatedFKPropName, true);
OneToOneAutoMapper autoMapper = new OneToOneAutoMapper(propertyWrapper);
//---------------Assert Precondition----------------
Assert.IsFalse(ownerType.HasProperty(owningFKPropName));
Assert.IsTrue(relatedType.HasProperty(relatedFKPropName));
//---------------Execute Test ----------------------
var relatedPropName = autoMapper.GetRelatedPropName();
//---------------Test Result -----------------------
Assert.AreEqual(relatedFKPropName, relatedPropName);
}
public void Test_GetRelatedPropName_NeitherHaveProps_NonDefaultNaming_ShouldReturnRevRelNameID()
{
//---------------Set up test pack-------------------
SetNonDefaultNamingConvention();
var ownerType = MockRepository.GenerateMock<FakeTypeWrapper>();
var relatedType = MockRepository.GenerateMock<FakeTypeWrapper>();
var reverseRelName = GetRandomString();
var relationshipName = GetRandomString();
var owningFKPropName = GetFKPropName(relationshipName);
var relatedFKPropName = GetFKPropName(reverseRelName);
PropertyWrapper propertyWrapper = MockRepository.GenerateStub<FakePropertyWrapper>();
SetupMockPropWrapper(propertyWrapper, ownerType, relatedType, relationshipName, reverseRelName);
ownerType.SetName("1111");
relatedType.SetName("2222");
OneToOneAutoMapper autoMapper = new OneToOneAutoMapper(propertyWrapper);
//---------------Assert Precondition----------------
Assert.IsFalse(ownerType.HasProperty(owningFKPropName));
Assert.IsFalse(relatedType.HasProperty(relatedFKPropName));
Assert.AreEqual(-1, ownerType.Name.CompareTo(relatedType.Name));
AssertMockPropSetupCorrectly(propertyWrapper, ownerType, relatedType, relationshipName, reverseRelName);
//---------------Execute Test ----------------------
var relatedPropName = autoMapper.GetRelatedPropName();
//---------------Test Result -----------------------
Assert.AreEqual(relatedFKPropName, relatedPropName);
}
public void Test_OwningBoHasForeignKey_OwnerHasProp_RelatedNotHasProp_ShouldReturnTrue()
{
//---------------Set up test pack-------------------
TypeWrapper ownerType; TypeWrapper relatedType;
string relatedFKPropName; string owningFKPropName;
var propertyWrapper
= GetPropertyWrapper(out ownerType, out relatedType, out relatedFKPropName, out owningFKPropName);
ownerType.SetHasProperty(owningFKPropName, true);
OneToOneAutoMapper autoMapper = new OneToOneAutoMapper(propertyWrapper);
//---------------Assert Precondition----------------
Assert.IsTrue(ownerType.HasProperty(owningFKPropName));
Assert.IsFalse(relatedType.HasProperty(relatedFKPropName));
//---------------Execute Test ----------------------
var owningBoHasForeignKey = autoMapper.OwningBoHasForeignKey;
//---------------Test Result -----------------------
Assert.IsTrue(owningBoHasForeignKey);
}
public void Test_Map_OwningBoHasFK_ShouldReturnRelatedTypePkName()
{
//---------------Set up test pack-------------------
TypeWrapper ownerType; TypeWrapper relatedType;
string relatedFKPropName; string owningFKPropName;
var propertyWrapper
= GetPropertyWrapper(out ownerType, out relatedType, out relatedFKPropName, out owningFKPropName);
relatedType.SetHasProperty(relatedFKPropName, true);
propertyWrapper.SetIsSingleRelationship(true);
OneToOneAutoMapper autoMapper = new OneToOneAutoMapper(propertyWrapper);
//---------------Assert Precondition----------------
Assert.IsFalse(autoMapper.OwningBoHasForeignKey);
Assert.IsTrue(propertyWrapper.IsSingleRelationship);
Assert.IsTrue(propertyWrapper.IsPublic);
Assert.IsFalse(propertyWrapper.IsInherited);
Assert.IsTrue(autoMapper.MustBeMapped());
//---------------Execute Test ----------------------
var relationshipDef = autoMapper.MapOneToOne();
//---------------Test Result -----------------------
Assert.IsNotNull(relationshipDef);
Assert.IsInstanceOf(typeof (SingleRelationshipDef), relationshipDef);
Assert.IsFalse(relationshipDef.OwningBOHasForeignKey);
Assert.AreEqual(DeleteParentAction.Prevent, relationshipDef.DeleteParentAction);
}
public void Test_OwningBoHasForeignKey_BothHave_FakeNameConvention_ShouldReturnFalse()
{
//---------------Set up test pack-------------------
SetNonDefaultNamingConvention();
TypeWrapper ownerType; TypeWrapper relatedType;
string relatedFKPropName; string owningFKPropName;
var propertyWrapper
= GetPropertyWrapper(out ownerType, out relatedType, out relatedFKPropName, out owningFKPropName);
ownerType.SetHasProperty(owningFKPropName, true);
relatedType.SetHasProperty(relatedFKPropName, true);
OneToOneAutoMapper autoMapper = new OneToOneAutoMapper(propertyWrapper);
//---------------Assert Precondition----------------
Assert.IsTrue(ownerType.HasProperty(owningFKPropName));
Assert.IsTrue(relatedType.HasProperty(relatedFKPropName));
Assert.AreNotEqual(propertyWrapper.Name, relatedType.Name);
//---------------Execute Test ----------------------
var owningBoHasForeignKey = autoMapper.OwningBoHasForeignKey;
//---------------Test Result -----------------------
Assert.IsTrue(owningBoHasForeignKey);
}
public void Test_OwningBOHasForeignKey_WhenIsComposition_AndNeitherHaveProps_ShouldRetFalse()
{
//---------------Set up test pack-------------------
SetNonDefaultNamingConvention();
TypeWrapper ownerType; TypeWrapper relatedType;
string relatedFKPropName; string owningFKPropName;
var propertyWrapper
= GetPropertyWrapper(out ownerType, out relatedType, out relatedFKPropName, out owningFKPropName);
ownerType.ClearReturnValue();
ownerType.SetName("ZZZZZ" + relatedType.Name);
propertyWrapper.SetOneToOneAttributeOnStub(RelationshipType.Composition);
/* propertyWrapper.Stub(pw => pw.GetAttribute<AutoMapOneToOneAttribute>()).Return(
new AutoMapOneToOneAttribute(RelationshipType.Composition));*/
OneToOneAutoMapper autoMapper = new OneToOneAutoMapper(propertyWrapper);
//---------------Assert Precondition----------------
Assert.IsFalse(ownerType.HasProperty(owningFKPropName));
Assert.IsFalse(relatedType.HasProperty(relatedFKPropName));
Assert.AreEqual(RelationshipType.Composition, GetAutomapAttribute(propertyWrapper).RelationshipType);
//---------------Execute Test ----------------------
var owningBoHasForeignKey = autoMapper.OwningBoHasForeignKey;
//---------------Test Result -----------------------
Assert.IsFalse(owningBoHasForeignKey);
}
public void Test_OwningBoHasForeignKey_NeitherHaveProps_OwnerLTRelated_ShouldReturnFalse()
{
//---------------Set up test pack-------------------
TypeWrapper ownerType;
string relatedFKPropName; string owningFKPropName;
ownerType = GetMockTypeWrapper(GetRandomString());
FakeTypeWrapper relatedType = MockRepository.GenerateMock<FakeTypeWrapper>();
relatedType.SetName("zzzzz");
var reverseRelName = GetRandomString();
var relationshipName = GetRandomString();
owningFKPropName = GetFKPropName(relationshipName);
relatedFKPropName = GetFKPropName(reverseRelName);
PropertyWrapper propertyWrapper1 = MockRepository.GenerateMock<FakePropertyWrapper>();
SetupMockPropWrapper(propertyWrapper1, ownerType, relatedType, relationshipName, reverseRelName);
var propertyWrapper
= propertyWrapper1;
ownerType.ClearReturnValue();
ownerType.SetName("aaaaa");
relatedType.SetName("zzzzz");
OneToOneAutoMapper autoMapper = new OneToOneAutoMapper(propertyWrapper);
//---------------Assert Precondition----------------
Assert.IsFalse(ownerType.HasProperty(owningFKPropName));
Assert.IsFalse(relatedType.HasProperty(relatedFKPropName));
Assert.AreEqual(1, relatedType.Name.CompareTo(ownerType.Name));
//---------------Execute Test ----------------------
var owningBoHasForeignKey = autoMapper.OwningBoHasForeignKey;
//---------------Test Result -----------------------
Assert.IsFalse(owningBoHasForeignKey);
}
public void Test_OwningBoHasForeignKey_NeitherHaveProps_NonDefaultNaming_ShouldReturnFalse()
{
//---------------Set up test pack-------------------
SetNonDefaultNamingConvention();
TypeWrapper ownerType; TypeWrapper relatedType;
string relatedFKPropName; string owningFKPropName;
var propertyWrapper
= GetPropertyWrapper(out ownerType, out relatedType, out relatedFKPropName, out owningFKPropName);
ownerType.ClearReturnValue();
ownerType.SetName("1111");
relatedType.SetName("2222");
OneToOneAutoMapper autoMapper = new OneToOneAutoMapper(propertyWrapper);
//---------------Assert Precondition----------------
Assert.IsFalse(ownerType.HasProperty(owningFKPropName));
Assert.IsFalse(relatedType.HasProperty(relatedFKPropName));
Assert.AreEqual(-1, ownerType.Name.CompareTo(relatedType.Name));
// AssertMockPropSetupCorrectly(propertyWrapper, ownerType, relatedType, relationshipName, reverseRelName);
//---------------Execute Test ----------------------
var owningBoHasForeignKey = autoMapper.OwningBoHasForeignKey;
//---------------Test Result -----------------------
Assert.IsFalse(owningBoHasForeignKey);
}
public void Test_Map_ShouldCreateRelProp_WithCorrectNames()
{
//---------------Set up test pack-------------------
TypeWrapper ownerType; TypeWrapper relatedType;
string relatedFKPropName; string owningFKPropName;
var propertyWrapper
= GetPropertyWrapper(out ownerType, out relatedType, out relatedFKPropName, out owningFKPropName);
propertyWrapper.SetIsSingleRelationship(true);
OneToOneAutoMapper autoMapper = new OneToOneAutoMapper(propertyWrapper);
var expectedReverseRelName = propertyWrapper.GetSingleReverseRelationshipName<AutoMapOneToOneAttribute>();
//---------------Assert Precondition----------------
Assert.IsTrue(propertyWrapper.IsSingleRelationship);
Assert.AreEqual(expectedReverseRelName, autoMapper.ReverseRelationshipName);
//---------------Execute Test ----------------------
var relationshipDef = autoMapper.MapOneToOne();
//---------------Test Result -----------------------
Assert.IsNotNull(relationshipDef);
Assert.IsInstanceOf(typeof (SingleRelationshipDef), relationshipDef);
Assert.AreEqual(1, relationshipDef.RelKeyDef.Count);
var relPropDef = relationshipDef.RelKeyDef[autoMapper.GetOwningPropName()];
Assert.AreEqual(autoMapper.GetRelatedPropName(), relPropDef.RelatedClassPropName);
}
public void Test_Map_ShouldSetRelationshipAsOneToOne()
{
//---------------Set up test pack-------------------
PropertyWrapper propertyWrapper = GetPropertyWrapper();
propertyWrapper.SetIsSingleRelationship(true);
OneToOneAutoMapper autoMapper = new OneToOneAutoMapper(propertyWrapper);
//---------------Assert Precondition----------------
Assert.IsTrue(propertyWrapper.IsSingleRelationship);
//---------------Execute Test ----------------------
var relationshipDef = autoMapper.MapOneToOne();
//---------------Test Result -----------------------
Assert.IsNotNull(relationshipDef);
Assert.IsTrue(relationshipDef.IsOneToOne);
}
public void Test_Map_ShouldSetReverseRelationshipName()
{
//---------------Set up test pack-------------------
PropertyWrapper propertyWrapper = GetPropertyWrapper();
propertyWrapper.SetIsSingleRelationship(true);
OneToOneAutoMapper autoMapper = new OneToOneAutoMapper(propertyWrapper);
var expectedReverseRelName = propertyWrapper.GetSingleReverseRelationshipName<AutoMapOneToOneAttribute>();
//---------------Assert Precondition----------------
Assert.IsTrue(propertyWrapper.IsSingleRelationship);
Assert.AreEqual(expectedReverseRelName, autoMapper.ReverseRelationshipName);
//---------------Execute Test ----------------------
var relationshipDef = autoMapper.MapOneToOne();
//---------------Test Result -----------------------
Assert.IsNotNull(relationshipDef);
Assert.IsInstanceOf(typeof (SingleRelationshipDef), relationshipDef);
Assert.AreEqual(expectedReverseRelName, relationshipDef.ReverseRelationshipName);
}
public void Test_CreateRelPropDef_WithDefaultIDConventionName_ShouldCreateWithCorrectOwningAndRelatedPropNames()
{
//---------------Set up test pack-------------------
TypeWrapper ownerType; TypeWrapper relatedType;
string relatedFKPropName; string owningFKPropName;
var propertyWrapper
= GetPropertyWrapper(out ownerType, out relatedType, out relatedFKPropName, out owningFKPropName);
ownerType.SetHasProperty(owningFKPropName, true);
relatedType.SetHasProperty(relatedFKPropName, true);
var autoMapper = new OneToOneAutoMapper(propertyWrapper);
//---------------Assert Precondition----------------
Assert.IsTrue(ownerType.HasProperty(owningFKPropName));
Assert.IsTrue(relatedType.HasProperty(relatedFKPropName));
Assert.IsNotNullOrEmpty(autoMapper.GetOwningPropName());
Assert.IsNotNullOrEmpty(autoMapper.GetRelatedPropName());
//---------------Execute Test ----------------------
var relPropDef = autoMapper.CreateRelPropDef();
//---------------Test Result -----------------------
Assert.IsNotNull(relPropDef);
Assert.AreEqual(autoMapper.GetOwningPropName(), relPropDef.OwnerPropertyName);
Assert.AreEqual(autoMapper.GetRelatedPropName(), relPropDef.RelatedClassPropName);
}
public void Test_OwningBOHasForeignKey_WhenIsAssociation_AndNeitherHaveProps_WhenOwnerGTRelated_ShouldReturnTrue_FixBug909()
{
//---------------Set up test pack-------------------
SetNonDefaultNamingConvention();
TypeWrapper ownerType; TypeWrapper relatedType;
string relatedFKPropName; string owningFKPropName;
var propertyWrapper
= GetPropertyWrapper(out ownerType, out relatedType, out relatedFKPropName, out owningFKPropName);
ownerType.ClearReturnValue();
ownerType.SetName("ZZZZZZ" + relatedType.Name);
propertyWrapper.SetOneToOneAttributeOnStub(RelationshipType.Association);
OneToOneAutoMapper autoMapper = new OneToOneAutoMapper(propertyWrapper);
//---------------Assert Precondition----------------
Assert.IsFalse(ownerType.HasProperty(owningFKPropName));
Assert.IsFalse(relatedType.HasProperty(relatedFKPropName));
Assert.AreEqual(RelationshipType.Association, GetAutomapAttribute(propertyWrapper).RelationshipType);
Assert.AreEqual(1, ownerType.Name.CompareTo(relatedType.Name), "OwnerNameShouldBeGreaterThanRelatedName");
//---------------Execute Test ----------------------
var owningBoHasForeignKey = autoMapper.OwningBoHasForeignKey;
//---------------Test Result -----------------------
Assert.IsTrue(owningBoHasForeignKey);
}
public void Test_ReverseRelationshipName_ShouldBeSameAsPropReverseRelName()
{
//---------------Set up test pack-------------------
PropertyWrapper propertyWrapper = MockRepository.GenerateMock<FakePropertyWrapper>();
var expectedRevRelName = GetRandomString();
propertyWrapper.SetOneToOneReverseRelName(expectedRevRelName);
OneToOneAutoMapper autoMapper = new OneToOneAutoMapper(propertyWrapper);
//---------------Assert Precondition----------------
Assert.AreEqual(expectedRevRelName, propertyWrapper.GetSingleReverseRelationshipName<AutoMapOneToOneAttribute>());
//---------------Execute Test ----------------------
var revRelName = autoMapper.ReverseRelationshipName;
//---------------Test Result -----------------------
Assert.AreEqual(expectedRevRelName, revRelName);
}
public void Test_OwningBOHasForeignKey_WhenIsAssociation_AndNeitherHaveProps_WhenOwnerLTRelated_ShouldReturnFalse_FixBug909()
{
//---------------Set up test pack-------------------
SetNonDefaultNamingConvention();
TypeWrapper ownerType; TypeWrapper relatedType;
var ownerTypeName = "A" + GetRandomString();
var propertyWrapper
= GetPropertyWrapper(out ownerType, out relatedType, ownerTypeName, "ZZZZZZ" + ownerTypeName);
propertyWrapper.SetOneToOneAttributeOnStub(RelationshipType.Association);
string owningFKPropName = GetFKPropName(propertyWrapper.Name);
var reverseRelName = propertyWrapper.GetSingleReverseRelationshipName<AutoMapOneToOneAttribute>();
string relatedFKPropName = GetFKPropName(reverseRelName);
OneToOneAutoMapper autoMapper = new OneToOneAutoMapper(propertyWrapper);
//---------------Assert Precondition----------------
Assert.IsFalse(ownerType.HasProperty(owningFKPropName));
Assert.IsFalse(relatedType.HasProperty(relatedFKPropName));
Assert.AreEqual(RelationshipType.Association, GetAutomapAttribute(propertyWrapper).RelationshipType);
Assert.Greater(ownerType.Name, relatedType.Name, "RelatedNameShouldBeGreaterThanOwnerName");
//---------------Execute Test ----------------------
var owningBoHasForeignKey = autoMapper.OwningBoHasForeignKey;
//---------------Test Result -----------------------
Assert.IsFalse(owningBoHasForeignKey, "ShouldNotBeOwningBOHasFK");
}
public void Test_MustBeMapped_WhenPropIsInherited_ShouldRetFalse()
{
//---------------Set up test pack-------------------
var propertyWrapper = MockRepository.GenerateStub<FakePropertyWrapper>();
propertyWrapper.Stub(wrapper => wrapper.IsPublic).Return(true);
propertyWrapper.Stub(wrapper => wrapper.IsInherited).Return(true);
propertyWrapper.Stub(wrapper => wrapper.IsSingleRelationship).Return(true);
propertyWrapper.Stub(wrapper => wrapper.PropertyInfo).Return(GetFakePropertyInfo());
propertyWrapper.Stub(wrapper => wrapper.HasOneToOneAttribute).Return(true);
propertyWrapper.Stub(wrapper => wrapper.DeclaringType).Return(GetFakeTypeWrapper());
OneToOneAutoMapper mapper = new OneToOneAutoMapper(propertyWrapper);
//---------------Assert Precondition----------------
Assert.IsFalse(propertyWrapper.IsStatic);
Assert.IsTrue(propertyWrapper.IsPublic);
Assert.IsFalse(propertyWrapper.HasManyToOneAttribute);
Assert.IsTrue(propertyWrapper.IsSingleRelationship);
Assert.IsFalse(propertyWrapper.HasIgnoreAttribute);
Assert.IsTrue(propertyWrapper.HasOneToOneAttribute);
Assert.IsNotNull(propertyWrapper.PropertyInfo);
Assert.IsNotNull(propertyWrapper.DeclaringType);
Assert.IsTrue(propertyWrapper.IsInherited);
//---------------Execute Test ----------------------
var mustBeMapped = mapper.MustBeMapped();
//---------------Test Result -----------------------
Assert.IsFalse(mustBeMapped);
}
public void Test_Map_WhenOwningBoHasFK_ShouldSetOwningBoHasFKTrue()
{
//---------------Set up test pack-------------------
TypeWrapper ownerType;
string owningFKPropName;
PropertyWrapper propertyWrapper = GetPropertyWrapper(out ownerType, out owningFKPropName);
ownerType.SetHasProperty(owningFKPropName, true);
propertyWrapper.SetIsSingleRelationship(true);
OneToOneAutoMapper autoMapper = new OneToOneAutoMapper(propertyWrapper);
//---------------Assert Precondition----------------
Assert.IsTrue(autoMapper.OwningBoHasForeignKey);
Assert.IsTrue(propertyWrapper.IsSingleRelationship);
//---------------Execute Test ----------------------
var relationshipDef = autoMapper.MapOneToOne();
//---------------Test Result -----------------------
Assert.IsNotNull(relationshipDef);
Assert.IsInstanceOf(typeof (SingleRelationshipDef), relationshipDef);
Assert.IsTrue(relationshipDef.OwningBOHasForeignKey);
Assert.AreEqual(DeleteParentAction.DoNothing, relationshipDef.DeleteParentAction);
}
