Added usecase for delete user and test cases for userdao and delele

usecase

Author: gmkumar2005

codebrag-dao/src/test/scala/com/softwaremill/codebrag/dao/user/UserDAOSpec.scala

@@ -370,7 +370,20 @@ class SQLUserDAOSpec extends FlatSpecWithSQL with ClearSQLDataAfterTest with Bef
     foundUser.get.notifications.commits.get.getMillis should equal(commitDate.getMillis)
     foundUser.get.notifications.followups.get.getMillis should equal(followupDate.getMillis)
   }
+ it should "deleta a user " taggedAs RequiresDb in {
+    // given
+    val user = UserAssembler.randomUser.withBasicAuth("user", "pass").withAdmin(set = false).withActive(set = false).get
+    userDAO.add(user)
+    val newAuth = Authentication.basic(user.authentication.username, "newpass")
 
+    // when
+    val modifiedUser = user.copy(authentication = newAuth, admin = true, active = true)
+    userDAO.delete(modifiedUser.id)
+    val deletedUser  = userDAO.findById(user.id)
+
+    // then
+    assert(deletedUser === None , "Deletion was attempted but found  " + deletedUser)
+  }
   "rememberNotifications" should "store dates properly" taggedAs RequiresDb in {
     // given
     val user = UserAssembler.randomUser.get
@@ -479,4 +492,5 @@ class SQLUserDAOSpec extends FlatSpecWithSQL with ClearSQLDataAfterTest with Bef
     partial should have size (2)
     partial.map(_.name).toSet should be (users.map(_.name).toSet)
   }
+  
 }

codebrag-service/src/main/scala/com/softwaremill/codebrag/usecases/user/DeleteUserUseCase.scala

@@ -0,0 +1,50 @@
+package com.softwaremill.codebrag.usecases.user
+
+import com.softwaremill.codebrag.dao.user.UserDAO
+import com.softwaremill.codebrag.usecases.assertions.UserAssertions
+import org.bson.types.ObjectId
+import com.softwaremill.codebrag.domain.{Authentication, User}
+import com.typesafe.scalalogging.slf4j.Logging
+import com.softwaremill.scalaval.Validation._
+
+case class DeleteUserForm(userId: ObjectId, newPassword: Option[String], admin: Option[Boolean], active: Option[Boolean]) {
+
+  def applyTo(user: User) = {
+    val modifiedAuth = newPassword.map { newPass =>
+      buildNewAuth(user.authentication.username, newPass)
+    } getOrElse user.authentication
+    user.copy(
+      admin = admin.getOrElse(user.admin),
+      active = active.getOrElse(user.active),
+      authentication = modifiedAuth
+    )
+  }
+
+  protected def buildNewAuth(username: String, password: String) = Authentication.basic(username, password)
+
+}
+
+class DeleteUserDetailsUseCase(protected val userDao: UserDAO) extends Logging {
+
+  import UserAssertions._
+
+  def execute(executorId: ObjectId, form: DeleteUserForm): Either[Errors, Unit] = {
+    assertUserWithId(executorId, mustBeActive, mustBeAdmin)(userDao)
+    val targetUser = loadUser(form.userId)
+    validateUserDetails(executorId, targetUser, form).whenOk[Unit] {      
+      logger.debug(s"Validation passed, attempting to delete user $targetUser")
+      userDao.delete(form.userId)
+    }
+  }
+
+  private def loadUser(userId: ObjectId) = userDao.findById(userId).getOrElse(throw new IllegalStateException(s"User $userId not found"))
+
+  private def validateUserDetails(executorId: ObjectId, user: User, form: DeleteUserForm) = {   
+    val changeOwnFlagsCheck = rule("userId") {
+      val isDeleteFlags = form.admin.isDefined || form.active.isDefined
+      (!isDeleteFlags || (isDeleteFlags && executorId != user.id), "Cannot delete own user")
+    }
+    validate(changeOwnFlagsCheck)
+  }
+
+}

codebrag-service/src/test/scala/com/softwaremill/codebrag/usecases/user/DeleteUserUseCaseSpec.scala

@@ -0,0 +1,89 @@
+package com.softwaremill.codebrag.usecases.user
+
+import org.scalatest.{BeforeAndAfter, FlatSpec}
+import org.scalatest.matchers.ShouldMatchers
+import org.scalatest.mock.MockitoSugar
+import com.softwaremill.codebrag.dao.user.UserDAO
+import org.mockito.Matchers._
+import org.mockito.Mockito._
+import com.softwaremill.codebrag.domain.builder.UserAssembler
+import com.softwaremill.codebrag.domain.{Authentication, User}
+import com.softwaremill.codebrag.usecases.assertions.{ActiveUserStatusRequiredException, AdminRoleRequiredException}
+import org.bson.types.ObjectId
+
+class DeleteUserUseCaseSpec extends FlatSpec with ShouldMatchers with BeforeAndAfter with MockitoSugar {
+
+  val userDao = mock[UserDAO]
+  val useCase = new DeleteUserDetailsUseCase(userDao)
+  
+  val InactiveUser = UserAssembler.randomUser.withActive(set = false).get
+  val ActiveUser = UserAssembler.randomUser.withActive().get
+
+  val ValidExecutor = UserAssembler.randomUser.withAdmin().withActive().get
+  val NonAdminExecutor = UserAssembler.randomUser.withActive().withAdmin(set = false).get
+  val InactiveExecutor = UserAssembler.randomUser.withActive(set = false).withAdmin().get
+
+  after {
+    reset(userDao)
+  }
+  
+  it should "not delete  user when executing user is neither admin nor active" in {
+    // given
+    setupReturningUserFromDB(NonAdminExecutor, InactiveExecutor)
+    val form = DeleteUserForm(ActiveUser.id, None, None, None)
+
+    // when
+    intercept[AdminRoleRequiredException] {
+      useCase.execute(NonAdminExecutor.id, form)
+    }
+    intercept[ActiveUserStatusRequiredException] {
+      useCase.execute(InactiveExecutor.id, form)
+    }
+
+    // then
+    verify(userDao, never()).delete(any[ObjectId])
+  }
+
+  it should "not allow to delete yourself" in {
+    // given
+    setupReturningUserFromDB(ValidExecutor)
+
+    // when
+    val ownChangeForm = DeleteUserForm(ValidExecutor.id, None, admin = Some(false), active = Some(false))
+    val Left(result) = useCase.execute(ValidExecutor.id, ownChangeForm)
+
+    // then
+    result should be(Map("userId" -> List("Cannot delete own user")))
+    verify(userDao, never()).delete(any[ObjectId])
+  }
+
+  
+  it should "delete user when validation passes" in {
+    // given
+    stubCurrentlyActiveUsersCountTo(0)
+    setupReturningUserFromDB(ValidExecutor, ActiveUser)
+
+    // when
+    val newAuth = Authentication.basic(ActiveUser.authentication.username, "secret")
+    val form = new DeleteUserForm(ActiveUser.id, newPassword = Some("secret"), admin = Some(true), active = None) {
+      override def buildNewAuth(username: String, password: String) = newAuth
+    }
+    val result = useCase.execute(ValidExecutor.id, form)
+
+    // then
+    result should be('right)
+    val expectedUser = form.applyTo(ActiveUser)
+    verify(userDao).delete(expectedUser.id)
+  }
+
+  private def stubCurrentlyActiveUsersCountTo(activeUsersCount: Int) {
+    when(userDao.countAllActive()).thenReturn(activeUsersCount)
+  }
+
+  private def setupReturningUserFromDB(users: User*) {
+    users.foreach { user =>
+      when(userDao.findById(user.id)).thenReturn(Some(user))
+    }
+  }
+
+}