Add a test

src/main/scala/gitbucket/core/service/AccountFederationService.scala

@@ -49,7 +49,7 @@ trait AccountFederationService {
     * @param preferredUserName Username
     * @return Available username
     */
-  private def findAvailableUserName(preferredUserName: Option[String], mailAddress: String)(implicit s: Session): Option[String] = {
+  def findAvailableUserName(preferredUserName: Option[String], mailAddress: String)(implicit s: Session): Option[String] = {
     preferredUserName.flatMap(n => extractSafeStringForUserName(n)).orElse(extractSafeStringForUserName(mailAddress)) match {
       case Some(safeUserName) =>
         getAccountByUserName(safeUserName, includeRemoved = true) match {
@@ -73,3 +73,5 @@ trait AccountFederationService {
   def createAccountFederation(issuer: String, subject: String, userName: String)(implicit s: Session): Unit =
     AccountFederations insert AccountFederation(issuer, subject, userName)
 }
+
+object AccountFederationService extends AccountFederationService with AccountService

src/test/scala/gitbucket/core/service/AccountFederationServiceSpec.scala

@@ -0,0 +1,94 @@
+package gitbucket.core.service
+
+import org.scalatest.FunSpec
+
+class AccountFederationServiceSpec extends FunSpec with ServiceSpecBase {
+
+  describe("getOrCreateFederatedUser") {
+    it("should create a federated account if it does not exist") {
+      withTestDB { implicit session =>
+        val actual = AccountFederationService.getOrCreateFederatedUser("someIssuer", "someSubject", "dummy@example.com", Some("foo"), Some("Foo"))
+        assert(actual.get.userName == "foo")
+        assert(actual.get.password == "")
+        assert(actual.get.fullName == "Foo")
+        assert(actual.get.mailAddress == "dummy@example.com")
+        assert(!actual.get.isAdmin)
+        assert(!actual.get.isGroupAccount)
+        assert(!actual.get.isRemoved)
+      }
+    }
+    it("should return the federated account") {
+      withTestDB { implicit session =>
+        generateNewAccount("someUser")
+        AccountFederationService.createAccountFederation("someIssuer", "someSubject", "someUser")
+
+        val actual = AccountFederationService.getOrCreateFederatedUser("someIssuer", "someSubject", "dummy@example.com", Some("dummy"), Some("dummy"))
+        assert(actual.get.userName == "someUser")
+      }
+    }
+    it("should return None if the federated account is disabled") {
+      withTestDB { implicit session =>
+        val user = generateNewAccount("someUser")
+        AccountFederationService.createAccountFederation("someIssuer", "someSubject", "someUser")
+        AccountService.updateAccount(user.copy(isRemoved = true))
+
+        val actual = AccountFederationService.getOrCreateFederatedUser("someIssuer", "someSubject", "dummy@example.com", Some("dummy"), Some("dummy"))
+        assert(actual.isEmpty)
+      }
+    }
+  }
+
+  describe("getAccountByFederation") {
+    it("should return the federated account") {
+      withTestDB { implicit session =>
+        generateNewAccount("someUser")
+        AccountFederationService.createAccountFederation("someIssuer", "someSubject", "someUser")
+
+        val actual = AccountFederationService.getAccountByFederation("someIssuer", "someSubject")
+        assert(actual.get.userName == "someUser")
+      }
+    }
+    it("should return the federated account regardless of disabled") {
+      withTestDB { implicit session =>
+        val user = generateNewAccount("someUser")
+        AccountFederationService.createAccountFederation("someIssuer", "someSubject", "someUser")
+        AccountService.updateAccount(user.copy(isRemoved = true))
+
+        val actual = AccountFederationService.getAccountByFederation("someIssuer", "someSubject")
+        assert(actual.get.userName == "someUser")
+      }
+    }
+    it("should return None if the issuer and the subject did not match") {
+      withTestDB { implicit session =>
+        val actual = AccountFederationService.getAccountByFederation("someIssuer", "anotherSubject")
+        assert(actual.isEmpty)
+      }
+    }
+  }
+
+  describe("findAvailableUserName") {
+    it("should return the preferredUserName if it is available") {
+      withTestDB { implicit session =>
+        assert(AccountFederationService.findAvailableUserName(Some("foo"), "dummy@example.com").contains("foo"))
+      }
+    }
+    it("should return guessed username if only email is given") {
+      withTestDB { implicit session =>
+        assert(AccountFederationService.findAvailableUserName(None, "bar@example.com").contains("bar"))
+      }
+    }
+    it("should return None if the preferredUserName is already taken") {
+      withTestDB { implicit session =>
+        generateNewAccount("foo")
+        assert(AccountFederationService.findAvailableUserName(Some("foo"), "dummy@example.com").isEmpty)
+      }
+    }
+    it("should return None if guessed username is already taken") {
+      withTestDB { implicit session =>
+        generateNewAccount("bar")
+        assert(AccountFederationService.findAvailableUserName(None, "bar@example.com").isEmpty)
+      }
+    }
+  }
+
+}