public void Can_Perform_Exists_On_RelationTypeRepository()
        {
            // Arrange
            var provider   = new PetaPocoUnitOfWorkProvider();
            var unitOfWork = provider.GetUnitOfWork();
            var repository = new RelationTypeRepository(unitOfWork);

            // Act
            var exists      = repository.Exists(3);
            var doesntExist = repository.Exists(5);

            // Assert
            Assert.That(exists, Is.True);
            Assert.That(doesntExist, Is.False);
        }
        public void Can_Perform_Exists_On_RelationTypeRepository()
        {
            // Arrange
            IScopeProvider provider = ScopeProvider;

            using (provider.CreateScope())
            {
                RelationTypeRepository repository = CreateRepository(provider);

                // Act
                bool exists      = repository.Exists(3);
                bool doesntExist = repository.Exists(9);

                // Assert
                Assert.That(exists, Is.True);
                Assert.That(doesntExist, Is.False);
            }
        }
        public void Can_Perform_Delete_On_RelationTypeRepository()
        {
            // Arrange
            var provider   = new PetaPocoUnitOfWorkProvider();
            var unitOfWork = provider.GetUnitOfWork();
            var repository = new RelationTypeRepository(unitOfWork);

            // Act
            var relationType = repository.Get(3);

            repository.Delete(relationType);
            unitOfWork.Commit();

            var exists = repository.Exists(3);

            // Assert
            Assert.That(exists, Is.False);
        }
        public void Can_Perform_Delete_On_RelationTypeRepository()
        {
            // Arrange
            IScopeProvider provider = ScopeProvider;

            using (provider.CreateScope())
            {
                RelationTypeRepository repository = CreateRepository(provider);

                // Act
                IRelationType relationType = repository.Get(3);
                repository.Delete(relationType);

                bool exists = repository.Exists(3);

                // Assert
                Assert.That(exists, Is.False);
            }
        }
        public void Can_Perform_Add_On_RelationTypeRepository()
        {
            // Arrange
            IScopeProvider provider = ScopeProvider;

            using (provider.CreateScope())
            {
                RelationTypeRepository repository = CreateRepository(provider);

                // Act
                var relateMemberToContent = new RelationType("Relate Member to Content", "relateMemberToContent", true, Constants.ObjectTypes.Member, Constants.ObjectTypes.Document);

                repository.Save(relateMemberToContent);

                // Assert
                Assert.That(relateMemberToContent.HasIdentity, Is.True);
                Assert.That(repository.Exists(relateMemberToContent.Id), Is.True);
            }
        }
        public void Can_Perform_Add_On_RelationTypeRepository()
        {
            // Arrange
            var provider = new PetaPocoUnitOfWorkProvider();
            var unitOfWork = provider.GetUnitOfWork();
            var repository = new RelationTypeRepository(unitOfWork);

            // Act
            var relateMemberToContent = new RelationType(new Guid("39eb0f98-b348-42a1-8662-e7eb18487560"),
                                                         new Guid("C66BA18E-EAF3-4CFF-8A22-41B16D66A972"),
                                                         "relateMemberToContent")
                                            {IsBidirectional = true, Name = "Relate Member to Content"};
            
            repository.AddOrUpdate(relateMemberToContent);
            unitOfWork.Commit();

            // Assert
            Assert.That(relateMemberToContent.HasIdentity, Is.True);
            Assert.That(repository.Exists(relateMemberToContent.Id), Is.True);

        }
        public void Can_Perform_Add_On_RelationTypeRepository()
        {
            // Arrange
            var provider   = new PetaPocoUnitOfWorkProvider();
            var unitOfWork = provider.GetUnitOfWork();
            var repository = new RelationTypeRepository(unitOfWork);

            // Act
            var relateMemberToContent = new RelationType(new Guid("39eb0f98-b348-42a1-8662-e7eb18487560"),
                                                         new Guid("C66BA18E-EAF3-4CFF-8A22-41B16D66A972"),
                                                         "relateMemberToContent")
            {
                IsBidirectional = true, Name = "Relate Member to Content"
            };

            repository.AddOrUpdate(relateMemberToContent);
            unitOfWork.Commit();

            // Assert
            Assert.That(relateMemberToContent.HasIdentity, Is.True);
            Assert.That(repository.Exists(relateMemberToContent.Id), Is.True);
        }
        public void Can_Perform_Add_On_RelationTypeRepository()
        {
            // Arrange
            var provider   = new PetaPocoUnitOfWorkProvider();
            var unitOfWork = provider.GetUnitOfWork();
            var repository = new RelationTypeRepository(unitOfWork);

            // Act
            var relateMemberToContent = new RelationType(new Guid(Constants.ObjectTypes.Member),
                                                         new Guid(Constants.ObjectTypes.Document),
                                                         "relateMemberToContent")
            {
                IsBidirectional = true, Name = "Relate Member to Content"
            };

            repository.AddOrUpdate(relateMemberToContent);
            unitOfWork.Commit();

            // Assert
            Assert.That(relateMemberToContent.HasIdentity, Is.True);
            Assert.That(repository.Exists(relateMemberToContent.Id), Is.True);
        }
        public void Can_Perform_Delete_On_RelationTypeRepository()
        {
            // Arrange
            var provider = new PetaPocoUnitOfWorkProvider();
            var unitOfWork = provider.GetUnitOfWork();
            var repository = new RelationTypeRepository(unitOfWork);

            // Act
            var relationType = repository.Get(3);
            repository.Delete(relationType);
            unitOfWork.Commit();

            var exists = repository.Exists(3);

            // Assert
            Assert.That(exists, Is.False);
        }
        public void Can_Perform_Exists_On_RelationTypeRepository()
        {
            // Arrange
            var provider = new PetaPocoUnitOfWorkProvider();
            var unitOfWork = provider.GetUnitOfWork();
            var repository = new RelationTypeRepository(unitOfWork);

            // Act
            var exists = repository.Exists(3);
            var doesntExist = repository.Exists(5);

            // Assert
            Assert.That(exists, Is.True);
            Assert.That(doesntExist, Is.False);
        }