diff --git a/src/Umbraco.Core/Models/Relation.cs b/src/Umbraco.Core/Models/Relation.cs
index c5fc47944b..a501a2e341 100644
--- a/src/Umbraco.Core/Models/Relation.cs
+++ b/src/Umbraco.Core/Models/Relation.cs
@@ -84,5 +84,14 @@ namespace Umbraco.Core.Models
                 OnPropertyChanged(CommentSelector);
             }
         }
+
+        /// <summary>
+        /// Gets the Id of the <see cref="RelationType"/> that this Relation is based on.
+        /// </summary>
+        [IgnoreDataMember]
+        public int RelationTypeId
+        {
+            get { return _relationType.Id; }
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Umbraco.Core/Persistence/Factories/RelationFactory.cs b/src/Umbraco.Core/Persistence/Factories/RelationFactory.cs
index 3c3882c118..9c5d23682d 100644
--- a/src/Umbraco.Core/Persistence/Factories/RelationFactory.cs
+++ b/src/Umbraco.Core/Persistence/Factories/RelationFactory.cs
@@ -32,7 +32,7 @@ namespace Umbraco.Core.Persistence.Factories
             var dto = new RelationDto
                           {
                               ChildId = entity.ChildId,
-                              Comment = entity.Comment,
+                              Comment = string.IsNullOrEmpty(entity.Comment) ? string.Empty : entity.Comment,
                               Datetime = entity.CreateDate,
                               ParentId = entity.ParentId,
                               RelationType = entity.RelationType.Id
diff --git a/src/Umbraco.Core/Persistence/Mappers/RelationMapper.cs b/src/Umbraco.Core/Persistence/Mappers/RelationMapper.cs
index 3e58420b84..a0dbb80805 100644
--- a/src/Umbraco.Core/Persistence/Mappers/RelationMapper.cs
+++ b/src/Umbraco.Core/Persistence/Mappers/RelationMapper.cs
@@ -30,7 +30,7 @@ namespace Umbraco.Core.Persistence.Mappers
             CacheMap<Relation, RelationDto>(src => src.Comment, dto => dto.Comment);
             CacheMap<Relation, RelationDto>(src => src.CreateDate, dto => dto.Datetime);
             CacheMap<Relation, RelationDto>(src => src.ParentId, dto => dto.ParentId);
-            CacheMap<Relation, RelationDto>(src => src.RelationType, dto => dto.RelationType);
+            CacheMap<Relation, RelationDto>(src => src.RelationTypeId, dto => dto.RelationType);
         }
 
         internal override string Map(string propertyName)
diff --git a/src/Umbraco.Core/Persistence/Repositories/ContentRepository.cs b/src/Umbraco.Core/Persistence/Repositories/ContentRepository.cs
index 0b827c98d7..09b020ff46 100644
--- a/src/Umbraco.Core/Persistence/Repositories/ContentRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/ContentRepository.cs
@@ -123,6 +123,8 @@ namespace Umbraco.Core.Persistence.Repositories
                            {
                                string.Format("DELETE FROM umbracoUser2NodeNotify WHERE nodeId = @Id"),
                                string.Format("DELETE FROM umbracoUser2NodePermission WHERE nodeId = @Id"),
+                               string.Format("DELETE FROM umbracoRelation WHERE parentId = @Id"),
+                               string.Format("DELETE FROM umbracoRelation WHERE childId = @Id"),
                                string.Format("DELETE FROM cmsTagRelationship WHERE nodeId = @Id"),
                                string.Format("DELETE FROM cmsDocument WHERE NodeId = @Id"),
                                string.Format("DELETE FROM cmsPropertyData WHERE contentNodeId = @Id"),
diff --git a/src/Umbraco.Tests/Persistence/Repositories/RelationRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/RelationRepositoryTest.cs
index d556c0635e..9fba87f316 100644
--- a/src/Umbraco.Tests/Persistence/Repositories/RelationRepositoryTest.cs
+++ b/src/Umbraco.Tests/Persistence/Repositories/RelationRepositoryTest.cs
@@ -1,10 +1,13 @@
 using System;
+using System.Linq;
 using NUnit.Framework;
 using Umbraco.Core.Models;
 using Umbraco.Core.Persistence.Caching;
+using Umbraco.Core.Persistence.Querying;
 using Umbraco.Core.Persistence.Repositories;
 using Umbraco.Core.Persistence.UnitOfWork;
 using Umbraco.Tests.TestHelpers;
+using Umbraco.Tests.TestHelpers.Entities;
 
 namespace Umbraco.Tests.Persistence.Repositories
 {
@@ -36,39 +39,200 @@ namespace Umbraco.Tests.Persistence.Repositories
 
         [Test]
         public void Can_Perform_Add_On_RelationRepository()
-        { }
+        {
+            // Arrange
+            var provider = new PetaPocoUnitOfWorkProvider();
+            var unitOfWork = provider.GetUnitOfWork();
+            var repositoryType = new RelationTypeRepository(unitOfWork);
+            var repository = new RelationRepository(unitOfWork, NullCacheProvider.Current, repositoryType);
+
+            // Act
+            var relationType = repositoryType.Get(1);
+            var relation = new Relation(1047, 1048) { RelationType = relationType };
+            repository.AddOrUpdate(relation);
+            unitOfWork.Commit();
+
+            // Assert
+            Assert.That(relation, Is.Not.Null);
+            Assert.That(relation.HasIdentity, Is.True);
+        }
 
         [Test]
         public void Can_Perform_Update_On_RelationRepository()
-        { }
+        {
+            // Arrange
+            var provider = new PetaPocoUnitOfWorkProvider();
+            var unitOfWork = provider.GetUnitOfWork();
+            var repositoryType = new RelationTypeRepository(unitOfWork);
+            var repository = new RelationRepository(unitOfWork, NullCacheProvider.Current, repositoryType);
+
+            // Act
+            var relation = repository.Get(1);
+            relation.Comment = "This relation has been updated";
+            repository.AddOrUpdate(relation);
+            unitOfWork.Commit();
+
+            var relationUpdated = repository.Get(1);
+
+            // Assert
+            Assert.That(relationUpdated, Is.Not.Null);
+            Assert.That(relationUpdated.Comment, Is.EqualTo("This relation has been updated"));
+            Assert.AreNotEqual(relationUpdated.UpdateDate, relation.UpdateDate);
+        }
 
         [Test]
         public void Can_Perform_Delete_On_RelationRepository()
-        { }
+        {
+            // Arrange
+            var provider = new PetaPocoUnitOfWorkProvider();
+            var unitOfWork = provider.GetUnitOfWork();
+            var repositoryType = new RelationTypeRepository(unitOfWork);
+            var repository = new RelationRepository(unitOfWork, NullCacheProvider.Current, repositoryType);
+
+            // Act
+            var relation = repository.Get(2);
+            repository.Delete(relation);
+            unitOfWork.Commit();
+
+            var exists = repository.Exists(2);
+
+            // Assert
+            Assert.That(exists, Is.False);
+        }
 
         [Test]
         public void Can_Perform_Get_On_RelationRepository()
-        { }
+        {
+            // Arrange
+            var provider = new PetaPocoUnitOfWorkProvider();
+            var unitOfWork = provider.GetUnitOfWork();
+            var repositoryType = new RelationTypeRepository(unitOfWork);
+            var repository = new RelationRepository(unitOfWork, NullCacheProvider.Current, repositoryType);
+
+            // Act
+            var relation = repository.Get(1);
+
+            // Assert
+            Assert.That(relation, Is.Not.Null);
+            Assert.That(relation.HasIdentity, Is.True);
+            Assert.That(relation.ChildId, Is.EqualTo(1047));
+            Assert.That(relation.ParentId, Is.EqualTo(1046));
+            Assert.That(relation.RelationType.Alias, Is.EqualTo("relateContentOnCopy"));
+        }
 
         [Test]
         public void Can_Perform_GetAll_On_RelationRepository()
-        { }
+        {
+            // Arrange
+            var provider = new PetaPocoUnitOfWorkProvider();
+            var unitOfWork = provider.GetUnitOfWork();
+            var repositoryType = new RelationTypeRepository(unitOfWork);
+            var repository = new RelationRepository(unitOfWork, NullCacheProvider.Current, repositoryType);
+
+            // Act
+            var relations = repository.GetAll();
+
+            // Assert
+            Assert.That(relations, Is.Not.Null);
+            Assert.That(relations.Any(), Is.True);
+            Assert.That(relations.Any(x => x == null), Is.False);
+            Assert.That(relations.Count(), Is.EqualTo(2));
+        }
 
         [Test]
         public void Can_Perform_GetAll_With_Params_On_RelationRepository()
-        { }
+        {
+            // Arrange
+            var provider = new PetaPocoUnitOfWorkProvider();
+            var unitOfWork = provider.GetUnitOfWork();
+            var repositoryType = new RelationTypeRepository(unitOfWork);
+            var repository = new RelationRepository(unitOfWork, NullCacheProvider.Current, repositoryType);
+
+            // Act
+            var relations = repository.GetAll(1, 2);
+
+            // Assert
+            Assert.That(relations, Is.Not.Null);
+            Assert.That(relations.Any(), Is.True);
+            Assert.That(relations.Any(x => x == null), Is.False);
+            Assert.That(relations.Count(), Is.EqualTo(2));
+        }
 
         [Test]
         public void Can_Perform_Exists_On_RelationRepository()
-        { }
+        {
+            // Arrange
+            var provider = new PetaPocoUnitOfWorkProvider();
+            var unitOfWork = provider.GetUnitOfWork();
+            var repositoryType = new RelationTypeRepository(unitOfWork);
+            var repository = new RelationRepository(unitOfWork, NullCacheProvider.Current, repositoryType);
+
+            // Act
+            var exists = repository.Exists(2);
+            var doesntExist = repository.Exists(5);
+
+            // Assert
+            Assert.That(exists, Is.True);
+            Assert.That(doesntExist, Is.False);
+        }
 
         [Test]
         public void Can_Perform_Count_On_RelationRepository()
-        { }
+        {
+            // Arrange
+            var provider = new PetaPocoUnitOfWorkProvider();
+            var unitOfWork = provider.GetUnitOfWork();
+            var repositoryType = new RelationTypeRepository(unitOfWork);
+            var repository = new RelationRepository(unitOfWork, NullCacheProvider.Current, repositoryType);
+
+            // Act
+            var query = Query<Relation>.Builder.Where(x => x.ParentId == 1046);
+            int count = repository.Count(query);
+
+            // Assert
+            Assert.That(count, Is.EqualTo(2));
+        }
 
         [Test]
         public void Can_Perform_GetByQuery_On_RelationRepository()
-        { }
+        {
+            // Arrange
+            var provider = new PetaPocoUnitOfWorkProvider();
+            var unitOfWork = provider.GetUnitOfWork();
+            var repositoryType = new RelationTypeRepository(unitOfWork);
+            var repository = new RelationRepository(unitOfWork, NullCacheProvider.Current, repositoryType);
+
+            // Act
+            var query = Query<Relation>.Builder.Where(x => x.RelationTypeId == 2);
+            var relations = repository.GetByQuery(query);
+
+            // Assert
+            Assert.That(relations, Is.Not.Null);
+            Assert.That(relations.Any(), Is.True);
+            Assert.That(relations.Any(x => x == null), Is.False);
+            Assert.That(relations.Count(), Is.EqualTo(2));
+        }
+
+        [Test]
+        public void Can_Delete_Content_And_Verify_Relation_Is_Removed()
+        {
+            // Arrange
+            var provider = new PetaPocoUnitOfWorkProvider();
+            var unitOfWork = provider.GetUnitOfWork();
+            var repositoryType = new RelationTypeRepository(unitOfWork);
+            var repository = new RelationRepository(unitOfWork, NullCacheProvider.Current, repositoryType);
+
+            var content = ServiceContext.ContentService.GetById(1047);
+            ServiceContext.ContentService.Delete(content, 0);
+
+            // Act
+            var shouldntExist = repository.Exists(1);
+            var shouldExist = repository.Exists(2);
+
+            // Assert
+            Assert.That(shouldntExist, Is.False);
+            Assert.That(shouldExist, Is.True);
+        }
 
         [TearDown]
         public override void TearDown()
@@ -83,10 +247,33 @@ namespace Umbraco.Tests.Persistence.Repositories
 
             var provider = new PetaPocoUnitOfWorkProvider();
             var unitOfWork = provider.GetUnitOfWork();
-            var repository = new RelationTypeRepository(unitOfWork);
+            var relationTypeRepository = new RelationTypeRepository(unitOfWork);
+            var relationRepository = new RelationRepository(unitOfWork, NullCacheProvider.Current, relationTypeRepository);
 
-            repository.AddOrUpdate(relateContent);
-            repository.AddOrUpdate(relateContentType);
+            relationTypeRepository.AddOrUpdate(relateContent);
+            relationTypeRepository.AddOrUpdate(relateContentType);
+            unitOfWork.Commit();
+
+            //Create and Save ContentType "umbTextpage" -> 1045
+            ContentType contentType = MockedContentTypes.CreateSimpleContentType("umbTextpage", "Textpage");
+            ServiceContext.ContentTypeService.Save(contentType);
+
+            //Create and Save Content "Homepage" based on "umbTextpage" -> 1046
+            Content textpage = MockedContent.CreateSimpleContent(contentType);
+            ServiceContext.ContentService.Save(textpage, 0);
+
+            //Create and Save Content "Text Page 1" based on "umbTextpage" -> 1047
+            Content subpage = MockedContent.CreateSimpleContent(contentType, "Text Page 1", textpage.Id);
+            ServiceContext.ContentService.Save(subpage, 0);
+
+            //Create and Save Content "Text Page 1" based on "umbTextpage" -> 1048
+            Content subpage2 = MockedContent.CreateSimpleContent(contentType, "Text Page 2", textpage.Id);
+            ServiceContext.ContentService.Save(subpage2, 0);
+
+            var relation = new Relation(textpage.Id, subpage.Id) {RelationType = relateContent, Comment = string.Empty};
+            var relation2 = new Relation(textpage.Id, subpage2.Id) { RelationType = relateContent, Comment = string.Empty};
+            relationRepository.AddOrUpdate(relation);
+            relationRepository.AddOrUpdate(relation2);
             unitOfWork.Commit();
         }
     }