mirror of
https://github.com/gitbucket/gitbucket.git
synced 2025-11-10 07:25:50 +01:00
Merge branch 'master' into group-description
This commit is contained in:
nazoking
@@ -1,91 +1,78 @@
|
||||
package gitbucket.core.service
|
||||
|
||||
import gitbucket.core.model._
|
||||
|
||||
import org.specs2.mutable.Specification
|
||||
|
||||
import java.util.Date
|
||||
import org.scalatest.FunSuite
|
||||
|
||||
|
||||
class AccessTokenServiceSpec extends Specification with ServiceSpecBase {
|
||||
class AccessTokenServiceSpec extends FunSuite with ServiceSpecBase {
|
||||
|
||||
"AccessTokenService" should {
|
||||
"generateAccessToken" in { withTestDB { implicit session =>
|
||||
AccessTokenService.generateAccessToken("root", "note") must be like{
|
||||
case (id, token) if id != 0 => ok
|
||||
}
|
||||
}}
|
||||
test("generateAccessToken") { withTestDB { implicit session =>
|
||||
assert(AccessTokenService.generateAccessToken("root", "note") match {
|
||||
case (id, token) => id != 0
|
||||
})
|
||||
}}
|
||||
|
||||
"getAccessTokens" in { withTestDB { implicit session =>
|
||||
val (id, token) = AccessTokenService.generateAccessToken("root", "note")
|
||||
val tokenHash = AccessTokenService.tokenToHash(token)
|
||||
test("getAccessTokens") { withTestDB { implicit session =>
|
||||
val (id, token) = AccessTokenService.generateAccessToken("root", "note")
|
||||
val tokenHash = AccessTokenService.tokenToHash(token)
|
||||
|
||||
AccessTokenService.getAccessTokens("root") must be like{
|
||||
case List(AccessToken(`id`, "root", `tokenHash`, "note")) => ok
|
||||
}
|
||||
}}
|
||||
assert(AccessTokenService.getAccessTokens("root") == List(AccessToken(`id`, "root", `tokenHash`, "note")))
|
||||
}}
|
||||
|
||||
"getAccessTokens(root) get root's tokens" in { withTestDB { implicit session =>
|
||||
val (id, token) = AccessTokenService.generateAccessToken("root", "note")
|
||||
val tokenHash = AccessTokenService.tokenToHash(token)
|
||||
val user2 = generateNewAccount("user2")
|
||||
AccessTokenService.generateAccessToken("user2", "note2")
|
||||
test("getAccessTokens(root) get root's tokens") { withTestDB { implicit session =>
|
||||
val (id, token) = AccessTokenService.generateAccessToken("root", "note")
|
||||
val tokenHash = AccessTokenService.tokenToHash(token)
|
||||
val user2 = generateNewAccount("user2")
|
||||
AccessTokenService.generateAccessToken("user2", "note2")
|
||||
|
||||
AccessTokenService.getAccessTokens("root") must be like{
|
||||
case List(AccessToken(`id`, "root", `tokenHash`, "note")) => ok
|
||||
}
|
||||
}}
|
||||
assert(AccessTokenService.getAccessTokens("root") == List(AccessToken(`id`, "root", `tokenHash`, "note")))
|
||||
}}
|
||||
|
||||
"deleteAccessToken" in { withTestDB { implicit session =>
|
||||
val (id, token) = AccessTokenService.generateAccessToken("root", "note")
|
||||
val user2 = generateNewAccount("user2")
|
||||
AccessTokenService.generateAccessToken("user2", "note2")
|
||||
test("deleteAccessToken") { withTestDB { implicit session =>
|
||||
val (id, token) = AccessTokenService.generateAccessToken("root", "note")
|
||||
val user2 = generateNewAccount("user2")
|
||||
AccessTokenService.generateAccessToken("user2", "note2")
|
||||
|
||||
AccessTokenService.deleteAccessToken("root", id)
|
||||
AccessTokenService.deleteAccessToken("root", id)
|
||||
|
||||
AccessTokenService.getAccessTokens("root") must beEmpty
|
||||
}}
|
||||
assert(AccessTokenService.getAccessTokens("root").isEmpty)
|
||||
}}
|
||||
|
||||
"getAccountByAccessToken" in { withTestDB { implicit session =>
|
||||
val (id, token) = AccessTokenService.generateAccessToken("root", "note")
|
||||
AccessTokenService.getAccountByAccessToken(token) must beSome.like {
|
||||
case user => user.userName must_== "root"
|
||||
}
|
||||
}}
|
||||
test("getAccountByAccessToken") { withTestDB { implicit session =>
|
||||
val (id, token) = AccessTokenService.generateAccessToken("root", "note")
|
||||
assert(AccessTokenService.getAccountByAccessToken(token) match {
|
||||
case Some(user) => user.userName == "root"
|
||||
})
|
||||
}}
|
||||
|
||||
"getAccountByAccessToken don't get removed account" in { withTestDB { implicit session =>
|
||||
val user2 = generateNewAccount("user2")
|
||||
val (id, token) = AccessTokenService.generateAccessToken("user2", "note")
|
||||
AccountService.updateAccount(user2.copy(isRemoved=true))
|
||||
test("getAccountByAccessToken don't get removed account") { withTestDB { implicit session =>
|
||||
val user2 = generateNewAccount("user2")
|
||||
val (id, token) = AccessTokenService.generateAccessToken("user2", "note")
|
||||
AccountService.updateAccount(user2.copy(isRemoved=true))
|
||||
|
||||
AccessTokenService.getAccountByAccessToken(token) must beEmpty
|
||||
}}
|
||||
assert(AccessTokenService.getAccountByAccessToken(token).isEmpty)
|
||||
}}
|
||||
|
||||
"generateAccessToken create uniq token" in { withTestDB { implicit session =>
|
||||
val tokenIt = List("token1","token1","token1","token2").iterator
|
||||
val service = new AccessTokenService{
|
||||
override def makeAccessTokenString:String = tokenIt.next
|
||||
}
|
||||
test("generateAccessToken create uniq token") { withTestDB { implicit session =>
|
||||
val tokenIt = List("token1","token1","token1","token2").iterator
|
||||
val service = new AccessTokenService{
|
||||
override def makeAccessTokenString:String = tokenIt.next
|
||||
}
|
||||
|
||||
service.generateAccessToken("root", "note1") must like{
|
||||
case (_, "token1") => ok
|
||||
}
|
||||
service.generateAccessToken("root", "note2") must like{
|
||||
case (_, "token2") => ok
|
||||
}
|
||||
}}
|
||||
assert(service.generateAccessToken("root", "note1")._2 == "token1")
|
||||
assert(service.generateAccessToken("root", "note2")._2 == "token2")
|
||||
}}
|
||||
|
||||
"when update Account.userName then AccessToken.userName changed" in { withTestDB { implicit session =>
|
||||
val user2 = generateNewAccount("user2")
|
||||
val (id, token) = AccessTokenService.generateAccessToken("user2", "note")
|
||||
import gitbucket.core.model.Profile._
|
||||
import profile.simple._
|
||||
Accounts.filter(_.userName === "user2".bind).map(_.userName).update("user3")
|
||||
test("when update Account.userName then AccessToken.userName changed") { withTestDB { implicit session =>
|
||||
val user2 = generateNewAccount("user2")
|
||||
val (id, token) = AccessTokenService.generateAccessToken("user2", "note")
|
||||
import gitbucket.core.model.Profile._
|
||||
import profile.simple._
|
||||
Accounts.filter(_.userName === "user2".bind).map(_.userName).update("user3")
|
||||
|
||||
AccessTokenService.getAccountByAccessToken(token) must beSome.like {
|
||||
case user => user.userName must_== "user3"
|
||||
}
|
||||
}}
|
||||
}
|
||||
assert(AccessTokenService.getAccountByAccessToken(token) match {
|
||||
case Some(user) => user.userName == "user3"
|
||||
})
|
||||
}}
|
||||
}
|
||||
|
||||
|
||||
@@ -1,102 +1,86 @@
|
||||
package gitbucket.core.service
|
||||
|
||||
import gitbucket.core.model.{Account, GroupMember}
|
||||
import org.specs2.mutable.Specification
|
||||
import java.util.Date
|
||||
import org.scalatest.FunSuite
|
||||
|
||||
class AccountServiceSpec extends Specification with ServiceSpecBase {
|
||||
class AccountServiceSpec extends FunSuite with ServiceSpecBase {
|
||||
|
||||
"AccountService" should {
|
||||
val RootMailAddress = "root@localhost"
|
||||
val RootMailAddress = "root@localhost"
|
||||
|
||||
"getAllUsers" in { withTestDB { implicit session =>
|
||||
AccountService.getAllUsers() must be like{
|
||||
case List(Account("root", "root", RootMailAddress, _, true, _, _, _, None, None, false, false, None)) => ok
|
||||
}
|
||||
}}
|
||||
test("getAllUsers") { withTestDB { implicit session =>
|
||||
assert(AccountService.getAllUsers() match {
|
||||
case List(Account("root", "root", RootMailAddress, _, true, _, _, _, None, None, false, false, None)) => true
|
||||
case _ => false
|
||||
})
|
||||
}}
|
||||
|
||||
"getAccountByUserName" in { withTestDB { implicit session =>
|
||||
AccountService.getAccountByUserName("root") must beSome.like {
|
||||
case user => user.userName must_== "root"
|
||||
}
|
||||
test("getAccountByUserName") { withTestDB { implicit session =>
|
||||
assert(AccountService.getAccountByUserName("root").get.userName == "root")
|
||||
assert(AccountService.getAccountByUserName("invalid user name").isEmpty)
|
||||
}}
|
||||
|
||||
AccountService.getAccountByUserName("invalid user name") must beNone
|
||||
}}
|
||||
test("getAccountByMailAddress") { withTestDB { implicit session =>
|
||||
assert(AccountService.getAccountByMailAddress(RootMailAddress).isDefined)
|
||||
}}
|
||||
|
||||
"getAccountByMailAddress" in { withTestDB { implicit session =>
|
||||
AccountService.getAccountByMailAddress(RootMailAddress) must beSome
|
||||
}}
|
||||
test("updateLastLoginDate") { withTestDB { implicit session =>
|
||||
val root = "root"
|
||||
def user() = AccountService.getAccountByUserName(root).getOrElse(sys.error(s"user $root does not exists"))
|
||||
|
||||
"updateLastLoginDate" in { withTestDB { implicit session =>
|
||||
val root = "root"
|
||||
def user() =
|
||||
AccountService.getAccountByUserName(root).getOrElse(sys.error(s"user $root does not exists"))
|
||||
assert(user().lastLoginDate.isEmpty)
|
||||
|
||||
user().lastLoginDate must beNone
|
||||
val date1 = new Date
|
||||
AccountService.updateLastLoginDate(root)
|
||||
user().lastLoginDate must beSome.like{ case date =>
|
||||
date must be_>(date1)
|
||||
}
|
||||
val date2 = new Date
|
||||
Thread.sleep(1000)
|
||||
AccountService.updateLastLoginDate(root)
|
||||
user().lastLoginDate must beSome.like{ case date =>
|
||||
date must be_>(date2)
|
||||
}
|
||||
}}
|
||||
val date1 = new Date
|
||||
AccountService.updateLastLoginDate(root)
|
||||
assert(user().lastLoginDate.get.compareTo(date1) > 0)
|
||||
|
||||
"updateAccount" in { withTestDB { implicit session =>
|
||||
val root = "root"
|
||||
def user() =
|
||||
AccountService.getAccountByUserName(root).getOrElse(sys.error(s"user $root does not exists"))
|
||||
val date2 = new Date
|
||||
Thread.sleep(1000)
|
||||
AccountService.updateLastLoginDate(root)
|
||||
assert(user().lastLoginDate.get.compareTo(date2) > 0)
|
||||
}}
|
||||
|
||||
val newAddress = "new mail address"
|
||||
AccountService.updateAccount(user().copy(mailAddress = newAddress))
|
||||
user().mailAddress must_== newAddress
|
||||
}}
|
||||
test("updateAccount") { withTestDB { implicit session =>
|
||||
val root = "root"
|
||||
def user() = AccountService.getAccountByUserName(root).getOrElse(sys.error(s"user $root does not exists"))
|
||||
|
||||
"group" in { withTestDB { implicit session =>
|
||||
val group1 = "group1"
|
||||
val user1 = "root"
|
||||
AccountService.createGroup(group1, None, None)
|
||||
val newAddress = "new mail address"
|
||||
AccountService.updateAccount(user().copy(mailAddress = newAddress))
|
||||
assert(user().mailAddress == newAddress)
|
||||
}}
|
||||
|
||||
AccountService.getGroupMembers(group1) must_== Nil
|
||||
AccountService.getGroupsByUserName(user1) must_== Nil
|
||||
test("group") { withTestDB { implicit session =>
|
||||
val group1 = "group1"
|
||||
val user1 = "root"
|
||||
AccountService.createGroup(group1, None, None)
|
||||
|
||||
AccountService.updateGroupMembers(group1, List((user1, true)))
|
||||
assert(AccountService.getGroupMembers(group1) == Nil)
|
||||
assert(AccountService.getGroupsByUserName(user1) == Nil)
|
||||
|
||||
AccountService.getGroupMembers(group1) must_== List(GroupMember(group1, user1, true))
|
||||
AccountService.getGroupsByUserName(user1) must_== List(group1)
|
||||
AccountService.updateGroupMembers(group1, List((user1, true)))
|
||||
|
||||
AccountService.updateGroupMembers(group1, Nil)
|
||||
assert(AccountService.getGroupMembers(group1) == List(GroupMember(group1, user1, true)))
|
||||
assert(AccountService.getGroupsByUserName(user1) == List(group1))
|
||||
|
||||
AccountService.getGroupMembers(group1) must_== Nil
|
||||
AccountService.getGroupsByUserName(user1) must_== Nil
|
||||
}}
|
||||
AccountService.updateGroupMembers(group1, Nil)
|
||||
|
||||
"createGroup" should { withTestDB { implicit session =>
|
||||
"save description" in {
|
||||
AccountService.createGroup("some-group", None, Some("some clever description"))
|
||||
val maybeGroup = AccountService.getAccountByUserName("some-group")
|
||||
assert(AccountService.getGroupMembers(group1) == Nil)
|
||||
assert(AccountService.getGroupsByUserName(user1) == Nil)
|
||||
}}
|
||||
|
||||
maybeGroup must beSome.like {
|
||||
case account => account.groupDescription must beSome("some clever description")
|
||||
}
|
||||
}
|
||||
}}
|
||||
test("createGroup save description") { withTestDB { implicit session =>
|
||||
AccountService.createGroup("some-group", None, Some("some clever description"))
|
||||
val maybeGroup = AccountService.getAccountByUserName("some-group")
|
||||
|
||||
"updateGroup" should { withTestDB { implicit session =>
|
||||
"save description" in {
|
||||
AccountService.createGroup("a-group", None, None)
|
||||
assert(maybeGroup.flatMap(_.groupDescription) == Some("some clever description"))
|
||||
}}
|
||||
|
||||
AccountService.updateGroup("a-group", None, Some("new description"), false)
|
||||
test("updateGroup save description") { withTestDB { implicit session =>
|
||||
AccountService.createGroup("a-group", None, None)
|
||||
|
||||
val group = AccountService.getAccountByUserName("a-group")
|
||||
group must beSome.like {
|
||||
case account => account.groupDescription must beSome("new description")
|
||||
}
|
||||
}
|
||||
}}
|
||||
}
|
||||
AccountService.updateGroup("a-group", None, Some("new description"), false)
|
||||
|
||||
val group = AccountService.getAccountByUserName("a-group")
|
||||
assert(group.flatMap(_.groupDescription) == Some("new description"))
|
||||
}}
|
||||
}
|
||||
|
||||
@@ -1,78 +0,0 @@
|
||||
package gitbucket.core.service
|
||||
|
||||
import gitbucket.core.model._
|
||||
import gitbucket.core.model.Profile._
|
||||
import profile.simple._
|
||||
|
||||
import org.specs2.mutable.Specification
|
||||
|
||||
import java.util.Date
|
||||
|
||||
|
||||
class CommitStatusServiceSpec extends Specification with ServiceSpecBase with CommitStatusService
|
||||
with RepositoryService with AccountService{
|
||||
val now = new java.util.Date()
|
||||
val fixture1 = CommitStatus(
|
||||
userName = "root",
|
||||
repositoryName = "repo",
|
||||
commitId = "0e97b8f59f7cdd709418bb59de53f741fd1c1bd7",
|
||||
context = "jenkins/test",
|
||||
creator = "tester",
|
||||
state = CommitState.PENDING,
|
||||
targetUrl = Some("http://example.com/target"),
|
||||
description = Some("description"),
|
||||
updatedDate = now,
|
||||
registeredDate = now)
|
||||
def findById(id: Int)(implicit s:Session) = CommitStatuses.filter(_.byPrimaryKey(id)).firstOption
|
||||
def generateFixture1(tester:Account)(implicit s:Session) = createCommitStatus(
|
||||
userName = fixture1.userName,
|
||||
repositoryName = fixture1.repositoryName,
|
||||
sha = fixture1.commitId,
|
||||
context = fixture1.context,
|
||||
state = fixture1.state,
|
||||
targetUrl = fixture1.targetUrl,
|
||||
description = fixture1.description,
|
||||
creator = tester,
|
||||
now = fixture1.registeredDate)
|
||||
"CommitStatusService" should {
|
||||
"createCommitState can insert and update" in { withTestDB { implicit session =>
|
||||
val tester = generateNewAccount(fixture1.creator)
|
||||
createRepository(fixture1.repositoryName,fixture1.userName,None,false)
|
||||
val id = generateFixture1(tester:Account)
|
||||
getCommitStatus(fixture1.userName, fixture1.repositoryName, id) must_==
|
||||
Some(fixture1.copy(commitStatusId=id))
|
||||
// other one can update
|
||||
val tester2 = generateNewAccount("tester2")
|
||||
val time2 = new java.util.Date();
|
||||
val id2 = createCommitStatus(
|
||||
userName = fixture1.userName,
|
||||
repositoryName = fixture1.repositoryName,
|
||||
sha = fixture1.commitId,
|
||||
context = fixture1.context,
|
||||
state = CommitState.SUCCESS,
|
||||
targetUrl = Some("http://example.com/target2"),
|
||||
description = Some("description2"),
|
||||
creator = tester2,
|
||||
now = time2)
|
||||
getCommitStatus(fixture1.userName, fixture1.repositoryName, id2) must_== Some(fixture1.copy(
|
||||
commitStatusId = id,
|
||||
creator = "tester2",
|
||||
state = CommitState.SUCCESS,
|
||||
targetUrl = Some("http://example.com/target2"),
|
||||
description = Some("description2"),
|
||||
updatedDate = time2))
|
||||
}}
|
||||
"getCommitStatus can find by commitId and context" in { withTestDB { implicit session =>
|
||||
val tester = generateNewAccount(fixture1.creator)
|
||||
createRepository(fixture1.repositoryName,fixture1.userName,None,false)
|
||||
val id = generateFixture1(tester:Account)
|
||||
getCommitStatus(fixture1.userName, fixture1.repositoryName, fixture1.commitId, fixture1.context) must_== Some(fixture1.copy(commitStatusId=id))
|
||||
}}
|
||||
"getCommitStatus can find by commitStatusId" in { withTestDB { implicit session =>
|
||||
val tester = generateNewAccount(fixture1.creator)
|
||||
createRepository(fixture1.repositoryName,fixture1.userName,None,false)
|
||||
val id = generateFixture1(tester:Account)
|
||||
getCommitStatus(fixture1.userName, fixture1.repositoryName, id) must_== Some(fixture1.copy(commitStatusId=id))
|
||||
}}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,74 @@
|
||||
package gitbucket.core.service
|
||||
|
||||
import gitbucket.core.model._
|
||||
import gitbucket.core.model.Profile._
|
||||
import profile.simple._
|
||||
import org.scalatest.FunSuite
|
||||
|
||||
|
||||
class CommitStatusServiceSpec extends FunSuite with ServiceSpecBase with CommitStatusService
|
||||
with RepositoryService with AccountService{
|
||||
val now = new java.util.Date()
|
||||
val fixture1 = CommitStatus(
|
||||
userName = "root",
|
||||
repositoryName = "repo",
|
||||
commitId = "0e97b8f59f7cdd709418bb59de53f741fd1c1bd7",
|
||||
context = "jenkins/test",
|
||||
creator = "tester",
|
||||
state = CommitState.PENDING,
|
||||
targetUrl = Some("http://example.com/target"),
|
||||
description = Some("description"),
|
||||
updatedDate = now,
|
||||
registeredDate = now)
|
||||
def findById(id: Int)(implicit s:Session) = CommitStatuses.filter(_.byPrimaryKey(id)).firstOption
|
||||
def generateFixture1(tester:Account)(implicit s:Session) = createCommitStatus(
|
||||
userName = fixture1.userName,
|
||||
repositoryName = fixture1.repositoryName,
|
||||
sha = fixture1.commitId,
|
||||
context = fixture1.context,
|
||||
state = fixture1.state,
|
||||
targetUrl = fixture1.targetUrl,
|
||||
description = fixture1.description,
|
||||
creator = tester,
|
||||
now = fixture1.registeredDate)
|
||||
test("createCommitState can insert and update") { withTestDB { implicit session =>
|
||||
val tester = generateNewAccount(fixture1.creator)
|
||||
insertRepository(fixture1.repositoryName,fixture1.userName,None,false)
|
||||
val id = generateFixture1(tester:Account)
|
||||
assert(getCommitStatus(fixture1.userName, fixture1.repositoryName, id) == Some(fixture1.copy(commitStatusId=id)))
|
||||
// other one can update
|
||||
val tester2 = generateNewAccount("tester2")
|
||||
val time2 = new java.util.Date();
|
||||
val id2 = createCommitStatus(
|
||||
userName = fixture1.userName,
|
||||
repositoryName = fixture1.repositoryName,
|
||||
sha = fixture1.commitId,
|
||||
context = fixture1.context,
|
||||
state = CommitState.SUCCESS,
|
||||
targetUrl = Some("http://example.com/target2"),
|
||||
description = Some("description2"),
|
||||
creator = tester2,
|
||||
now = time2)
|
||||
assert(getCommitStatus(fixture1.userName, fixture1.repositoryName, id2) == Some(fixture1.copy(
|
||||
commitStatusId = id,
|
||||
creator = "tester2",
|
||||
state = CommitState.SUCCESS,
|
||||
targetUrl = Some("http://example.com/target2"),
|
||||
description = Some("description2"),
|
||||
updatedDate = time2)))
|
||||
}}
|
||||
|
||||
test("getCommitStatus can find by commitId and context") { withTestDB { implicit session =>
|
||||
val tester = generateNewAccount(fixture1.creator)
|
||||
insertRepository(fixture1.repositoryName,fixture1.userName,None,false)
|
||||
val id = generateFixture1(tester:Account)
|
||||
assert(getCommitStatus(fixture1.userName, fixture1.repositoryName, fixture1.commitId, fixture1.context) == Some(fixture1.copy(commitStatusId=id)))
|
||||
}}
|
||||
|
||||
test("getCommitStatus can find by commitStatusId") { withTestDB { implicit session =>
|
||||
val tester = generateNewAccount(fixture1.creator)
|
||||
insertRepository(fixture1.repositoryName,fixture1.userName,None,false)
|
||||
val id = generateFixture1(tester:Account)
|
||||
assert(getCommitStatus(fixture1.userName, fixture1.repositoryName, id) == Some(fixture1.copy(commitStatusId=id)))
|
||||
}}
|
||||
}
|
||||
@@ -2,49 +2,44 @@ package gitbucket.core.service
|
||||
|
||||
import gitbucket.core.model._
|
||||
import gitbucket.core.service.IssuesService._
|
||||
|
||||
import org.specs2.mutable.Specification
|
||||
|
||||
import java.util.Date
|
||||
import org.scalatest.FunSuite
|
||||
|
||||
|
||||
class IssuesServiceSpec extends Specification with ServiceSpecBase {
|
||||
"IssuesService" should {
|
||||
"getCommitStatues" in { withTestDB { implicit session =>
|
||||
val user1 = generateNewUserWithDBRepository("user1","repo1")
|
||||
class IssuesServiceSpec extends FunSuite with ServiceSpecBase {
|
||||
test("getCommitStatues") { withTestDB { implicit session =>
|
||||
val user1 = generateNewUserWithDBRepository("user1","repo1")
|
||||
|
||||
def getCommitStatues = dummyService.getCommitStatues(List(("user1","repo1",1),("user1","repo1",2)))
|
||||
def getCommitStatues = dummyService.getCommitStatues(List(("user1","repo1",1),("user1","repo1",2)))
|
||||
|
||||
getCommitStatues must_== Map.empty
|
||||
assert(getCommitStatues == Map.empty)
|
||||
|
||||
val now = new java.util.Date()
|
||||
val issueId = generateNewIssue("user1","repo1")
|
||||
issueId must_== 1
|
||||
val now = new java.util.Date()
|
||||
val issueId = generateNewIssue("user1","repo1")
|
||||
assert(issueId == 1)
|
||||
|
||||
getCommitStatues must_== Map.empty
|
||||
assert(getCommitStatues == Map.empty)
|
||||
|
||||
val cs = dummyService.createCommitStatus("user1","repo1","shasha", "default", CommitState.SUCCESS, Some("http://exmple.com/ci"), Some("exampleService"), now, user1)
|
||||
val cs = dummyService.createCommitStatus("user1","repo1","shasha", "default", CommitState.SUCCESS, Some("http://exmple.com/ci"), Some("exampleService"), now, user1)
|
||||
|
||||
getCommitStatues must_== Map.empty
|
||||
assert(getCommitStatues == Map.empty)
|
||||
|
||||
val (is2, pr2) = generateNewPullRequest("user1/repo1/master","user1/repo1/feature1")
|
||||
pr2.issueId must_== 2
|
||||
val (is2, pr2) = generateNewPullRequest("user1/repo1/master","user1/repo1/feature1")
|
||||
assert(pr2.issueId == 2)
|
||||
|
||||
// if there are no statuses, state is none
|
||||
getCommitStatues must_== Map.empty
|
||||
// if there are no statuses, state is none
|
||||
assert(getCommitStatues == Map.empty)
|
||||
|
||||
// if there is a status, state is that
|
||||
val cs2 = dummyService.createCommitStatus("user1","repo1","feature1", "default", CommitState.SUCCESS, Some("http://exmple.com/ci"), Some("exampleService"), now, user1)
|
||||
getCommitStatues must_== Map(("user1","repo1",2) -> CommitStatusInfo(1,1,Some("default"),Some(CommitState.SUCCESS),Some("http://exmple.com/ci"),Some("exampleService")))
|
||||
// if there is a status, state is that
|
||||
val cs2 = dummyService.createCommitStatus("user1","repo1","feature1", "default", CommitState.SUCCESS, Some("http://exmple.com/ci"), Some("exampleService"), now, user1)
|
||||
assert(getCommitStatues == Map(("user1","repo1",2) -> CommitStatusInfo(1,1,Some("default"),Some(CommitState.SUCCESS),Some("http://exmple.com/ci"),Some("exampleService"))))
|
||||
|
||||
// if there are two statuses, state is none
|
||||
val cs3 = dummyService.createCommitStatus("user1","repo1","feature1", "pend", CommitState.PENDING, Some("http://exmple.com/ci"), Some("exampleService"), now, user1)
|
||||
getCommitStatues must_== Map(("user1","repo1",2) -> CommitStatusInfo(2,1,None,None,None,None))
|
||||
// if there are two statuses, state is none
|
||||
val cs3 = dummyService.createCommitStatus("user1","repo1","feature1", "pend", CommitState.PENDING, Some("http://exmple.com/ci"), Some("exampleService"), now, user1)
|
||||
assert(getCommitStatues == Map(("user1","repo1",2) -> CommitStatusInfo(2,1,None,None,None,None)))
|
||||
|
||||
// get only statuses in query issues
|
||||
val (is3, pr3) = generateNewPullRequest("user1/repo1/master","user1/repo1/feature3")
|
||||
val cs4 = dummyService.createCommitStatus("user1","repo1","feature3", "none", CommitState.PENDING, None, None, now, user1)
|
||||
getCommitStatues must_== Map(("user1","repo1",2) -> CommitStatusInfo(2,1,None,None,None,None))
|
||||
} }
|
||||
}
|
||||
// get only statuses in query issues
|
||||
val (is3, pr3) = generateNewPullRequest("user1/repo1/master","user1/repo1/feature3")
|
||||
val cs4 = dummyService.createCommitStatus("user1","repo1","feature3", "none", CommitState.PENDING, None, None, now, user1)
|
||||
assert(getCommitStatues == Map(("user1","repo1",2) -> CommitStatusInfo(2,1,None,None,None,None)))
|
||||
} }
|
||||
}
|
||||
115
src/test/scala/gitbucket/core/service/LabelsServiceSpec.scala
Normal file
115
src/test/scala/gitbucket/core/service/LabelsServiceSpec.scala
Normal file
@@ -0,0 +1,115 @@
|
||||
package gitbucket.core.service
|
||||
|
||||
import gitbucket.core.model._
|
||||
import org.scalatest.FunSpec
|
||||
|
||||
class LabelsServiceSpec extends FunSpec with ServiceSpecBase {
|
||||
describe("getLabels") {
|
||||
it("should be empty when not have any labels") { withTestDB { implicit session =>
|
||||
generateNewUserWithDBRepository("user1", "repo1")
|
||||
|
||||
generateNewUserWithDBRepository("user1", "repo2")
|
||||
dummyService.createLabel("user1", "repo2", "label1", "000000")
|
||||
|
||||
generateNewUserWithDBRepository("user2", "repo1")
|
||||
dummyService.createLabel("user2", "repo1", "label1", "000000")
|
||||
|
||||
assert(dummyService.getLabels("user1", "repo1").isEmpty)
|
||||
}}
|
||||
it("should return contained labels") { withTestDB { implicit session =>
|
||||
generateNewUserWithDBRepository("user1", "repo1")
|
||||
val labelId1 = dummyService.createLabel("user1", "repo1", "label1", "000000")
|
||||
val labelId2 = dummyService.createLabel("user1", "repo1", "label2", "ffffff")
|
||||
|
||||
generateNewUserWithDBRepository("user1", "repo2")
|
||||
dummyService.createLabel("user1", "repo2", "label1", "000000")
|
||||
|
||||
generateNewUserWithDBRepository("user2", "repo1")
|
||||
dummyService.createLabel("user2", "repo1", "label1", "000000")
|
||||
|
||||
def getLabels = dummyService.getLabels("user1", "repo1")
|
||||
|
||||
assert(getLabels.length == 2)
|
||||
assert(getLabels == List(
|
||||
Label("user1", "repo1", labelId1, "label1", "000000"),
|
||||
Label("user1", "repo1", labelId2, "label2", "ffffff"))
|
||||
)
|
||||
}}
|
||||
}
|
||||
|
||||
describe("getLabel") {
|
||||
it("should return None when the label not exist") { withTestDB { implicit session =>
|
||||
generateNewUserWithDBRepository("user1", "repo1")
|
||||
|
||||
assert(dummyService.getLabel("user1", "repo1", 1) == None)
|
||||
assert(dummyService.getLabel("user1", "repo1", "label1") == None)
|
||||
}}
|
||||
it("should return a label fetched by label id") { withTestDB { implicit session =>
|
||||
generateNewUserWithDBRepository("user1", "repo1")
|
||||
val labelId1 = dummyService.createLabel("user1", "repo1", "label1", "000000")
|
||||
dummyService.createLabel("user1", "repo1", "label2", "ffffff")
|
||||
|
||||
generateNewUserWithDBRepository("user1", "repo2")
|
||||
dummyService.createLabel("user1", "repo2", "label1", "000000")
|
||||
|
||||
generateNewUserWithDBRepository("user2", "repo1")
|
||||
dummyService.createLabel("user2", "repo1", "label1", "000000")
|
||||
|
||||
def getLabel = dummyService.getLabel("user1", "repo1", labelId1)
|
||||
assert(getLabel == Some(Label("user1", "repo1", labelId1, "label1", "000000")))
|
||||
}}
|
||||
it("should return a label fetched by label name") { withTestDB { implicit session =>
|
||||
generateNewUserWithDBRepository("user1", "repo1")
|
||||
val labelId1 = dummyService.createLabel("user1", "repo1", "label1", "000000")
|
||||
dummyService.createLabel("user1", "repo1", "label2", "ffffff")
|
||||
|
||||
generateNewUserWithDBRepository("user1", "repo2")
|
||||
dummyService.createLabel("user1", "repo2", "label1", "000000")
|
||||
|
||||
generateNewUserWithDBRepository("user2", "repo1")
|
||||
dummyService.createLabel("user2", "repo1", "label1", "000000")
|
||||
|
||||
def getLabel = dummyService.getLabel("user1", "repo1", "label1")
|
||||
getLabel == Some(Label("user1", "repo1", labelId1, "label1", "000000"))
|
||||
}}
|
||||
}
|
||||
describe("createLabel") {
|
||||
it("should return accurate label id") { withTestDB { implicit session =>
|
||||
generateNewUserWithDBRepository("user1", "repo1")
|
||||
generateNewUserWithDBRepository("user1", "repo2")
|
||||
generateNewUserWithDBRepository("user2", "repo1")
|
||||
dummyService.createLabel("user1", "repo1", "label1", "000000")
|
||||
dummyService.createLabel("user1", "repo2", "label1", "000000")
|
||||
dummyService.createLabel("user2", "repo1", "label1", "000000")
|
||||
val labelId = dummyService.createLabel("user1", "repo1", "label2", "000000")
|
||||
assert(labelId == 4)
|
||||
def getLabel = dummyService.getLabel("user1", "repo1", labelId)
|
||||
assert(getLabel == Some(Label("user1", "repo1", labelId, "label2", "000000")))
|
||||
}}
|
||||
}
|
||||
describe("updateLabel") {
|
||||
it("should change target label") { withTestDB { implicit session =>
|
||||
generateNewUserWithDBRepository("user1", "repo1")
|
||||
generateNewUserWithDBRepository("user1", "repo2")
|
||||
generateNewUserWithDBRepository("user2", "repo1")
|
||||
val labelId = dummyService.createLabel("user1", "repo1", "label1", "000000")
|
||||
dummyService.createLabel("user1", "repo2", "label1", "000000")
|
||||
dummyService.createLabel("user2", "repo1", "label1", "000000")
|
||||
dummyService.updateLabel("user1", "repo1", labelId, "updated-label", "ffffff")
|
||||
def getLabel = dummyService.getLabel("user1", "repo1", labelId)
|
||||
assert(getLabel == Some(Label("user1", "repo1", labelId, "updated-label", "ffffff")))
|
||||
}}
|
||||
}
|
||||
describe("deleteLabel") {
|
||||
it("should remove target label") { withTestDB { implicit session =>
|
||||
generateNewUserWithDBRepository("user1", "repo1")
|
||||
generateNewUserWithDBRepository("user1", "repo2")
|
||||
generateNewUserWithDBRepository("user2", "repo1")
|
||||
val labelId = dummyService.createLabel("user1", "repo1", "label1", "000000")
|
||||
dummyService.createLabel("user1", "repo2", "label1", "000000")
|
||||
dummyService.createLabel("user2", "repo1", "label1", "000000")
|
||||
dummyService.deleteLabel("user1", "repo1", labelId)
|
||||
assert(dummyService.getLabel("user1", "repo1", labelId) == None)
|
||||
}}
|
||||
}
|
||||
}
|
||||
@@ -1,26 +1,17 @@
|
||||
package gitbucket.core.service
|
||||
|
||||
import gitbucket.core.model._
|
||||
import gitbucket.core.util.JGitUtil
|
||||
import gitbucket.core.util.Directory._
|
||||
import gitbucket.core.util.Implicits._
|
||||
import gitbucket.core.util.ControlUtil._
|
||||
import gitbucket.core.util.GitSpecUtil._
|
||||
|
||||
import org.apache.commons.io.FileUtils
|
||||
import org.eclipse.jgit.api.Git
|
||||
import org.eclipse.jgit.dircache.DirCache
|
||||
import org.eclipse.jgit.lib._
|
||||
import org.eclipse.jgit.revwalk._
|
||||
import org.eclipse.jgit.treewalk._
|
||||
import org.specs2.mutable.Specification
|
||||
import org.scalatest.FunSpec
|
||||
|
||||
import java.io.File
|
||||
import java.nio.file._
|
||||
import java.util.Date
|
||||
|
||||
class MergeServiceSpec extends Specification {
|
||||
sequential
|
||||
class MergeServiceSpec extends FunSpec {
|
||||
val service = new MergeService{}
|
||||
val branch = "master"
|
||||
val issueId = 10
|
||||
@@ -36,95 +27,95 @@ class MergeServiceSpec extends Specification {
|
||||
createFile(git, s"refs/heads/${branch}", "test.txt", "hoge2" )
|
||||
createFile(git, s"refs/pull/${issueId}/head", "test.txt", "hoge4" )
|
||||
}
|
||||
"checkConflict, checkConflictCache" should {
|
||||
"checkConflict false if not conflicted, and create cache" in {
|
||||
describe("checkConflict, checkConflictCache") {
|
||||
it("checkConflict false if not conflicted, and create cache") {
|
||||
val repo1Dir = initRepository("user1","repo1")
|
||||
service.checkConflictCache("user1", "repo1", branch, issueId) mustEqual None
|
||||
assert(service.checkConflictCache("user1", "repo1", branch, issueId) == None)
|
||||
val conflicted = service.checkConflict("user1", "repo1", branch, issueId)
|
||||
service.checkConflictCache("user1", "repo1", branch, issueId) mustEqual Some(false)
|
||||
conflicted mustEqual false
|
||||
assert(service.checkConflictCache("user1", "repo1", branch, issueId) == Some(false))
|
||||
assert(conflicted == false)
|
||||
}
|
||||
"checkConflict true if not conflicted, and create cache" in {
|
||||
val repo1Dir = initRepository("user1","repo1")
|
||||
using(Git.open(repo1Dir)){ git =>
|
||||
it("checkConflict true if not conflicted, and create cache") {
|
||||
val repo2Dir = initRepository("user1","repo2")
|
||||
using(Git.open(repo2Dir)){ git =>
|
||||
createConfrict(git)
|
||||
}
|
||||
service.checkConflictCache("user1", "repo1", branch, issueId) mustEqual None
|
||||
val conflicted = service.checkConflict("user1", "repo1", branch, issueId)
|
||||
conflicted mustEqual true
|
||||
service.checkConflictCache("user1", "repo1", branch, issueId) mustEqual Some(true)
|
||||
assert(service.checkConflictCache("user1", "repo2", branch, issueId) == None)
|
||||
val conflicted = service.checkConflict("user1", "repo2", branch, issueId)
|
||||
assert(conflicted == true)
|
||||
assert(service.checkConflictCache("user1", "repo2", branch, issueId) == Some(true))
|
||||
}
|
||||
}
|
||||
"checkConflictCache" should {
|
||||
"merged cache invalid if origin branch moved" in {
|
||||
val repo1Dir = initRepository("user1","repo1")
|
||||
service.checkConflict("user1", "repo1", branch, issueId) mustEqual false
|
||||
service.checkConflictCache("user1", "repo1", branch, issueId) mustEqual Some(false)
|
||||
using(Git.open(repo1Dir)){ git =>
|
||||
describe("checkConflictCache") {
|
||||
it("merged cache invalid if origin branch moved") {
|
||||
val repo3Dir = initRepository("user1","repo3")
|
||||
assert(service.checkConflict("user1", "repo3", branch, issueId) == false)
|
||||
assert(service.checkConflictCache("user1", "repo3", branch, issueId) == Some(false))
|
||||
using(Git.open(repo3Dir)){ git =>
|
||||
createFile(git, s"refs/heads/${branch}", "test.txt", "hoge2" )
|
||||
}
|
||||
service.checkConflictCache("user1", "repo1", branch, issueId) mustEqual None
|
||||
assert(service.checkConflictCache("user1", "repo3", branch, issueId) == None)
|
||||
}
|
||||
"merged cache invalid if request branch moved" in {
|
||||
val repo1Dir = initRepository("user1","repo1")
|
||||
service.checkConflict("user1", "repo1", branch, issueId) mustEqual false
|
||||
service.checkConflictCache("user1", "repo1", branch, issueId) mustEqual Some(false)
|
||||
using(Git.open(repo1Dir)){ git =>
|
||||
it("merged cache invalid if request branch moved") {
|
||||
val repo4Dir = initRepository("user1","repo4")
|
||||
assert(service.checkConflict("user1", "repo4", branch, issueId) == false)
|
||||
assert(service.checkConflictCache("user1", "repo4", branch, issueId) == Some(false))
|
||||
using(Git.open(repo4Dir)){ git =>
|
||||
createFile(git, s"refs/pull/${issueId}/head", "test.txt", "hoge4" )
|
||||
}
|
||||
service.checkConflictCache("user1", "repo1", branch, issueId) mustEqual None
|
||||
assert(service.checkConflictCache("user1", "repo4", branch, issueId) == None)
|
||||
}
|
||||
"merged cache invalid if origin branch moved" in {
|
||||
val repo1Dir = initRepository("user1","repo1")
|
||||
service.checkConflict("user1", "repo1", branch, issueId) mustEqual false
|
||||
service.checkConflictCache("user1", "repo1", branch, issueId) mustEqual Some(false)
|
||||
using(Git.open(repo1Dir)){ git =>
|
||||
it("should merged cache invalid if origin branch moved") {
|
||||
val repo5Dir = initRepository("user1","repo5")
|
||||
assert(service.checkConflict("user1", "repo5", branch, issueId) == false)
|
||||
assert(service.checkConflictCache("user1", "repo5", branch, issueId) == Some(false))
|
||||
using(Git.open(repo5Dir)){ git =>
|
||||
createFile(git, s"refs/heads/${branch}", "test.txt", "hoge2" )
|
||||
}
|
||||
service.checkConflictCache("user1", "repo1", branch, issueId) mustEqual None
|
||||
assert(service.checkConflictCache("user1", "repo5", branch, issueId) == None)
|
||||
}
|
||||
"conflicted cache invalid if request branch moved" in {
|
||||
val repo1Dir = initRepository("user1","repo1")
|
||||
using(Git.open(repo1Dir)){ git =>
|
||||
it("conflicted cache invalid if request branch moved") {
|
||||
val repo6Dir = initRepository("user1","repo6")
|
||||
using(Git.open(repo6Dir)){ git =>
|
||||
createConfrict(git)
|
||||
}
|
||||
service.checkConflict("user1", "repo1", branch, issueId) mustEqual true
|
||||
service.checkConflictCache("user1", "repo1", branch, issueId) mustEqual Some(true)
|
||||
using(Git.open(repo1Dir)){ git =>
|
||||
assert(service.checkConflict("user1", "repo6", branch, issueId) == true)
|
||||
assert(service.checkConflictCache("user1", "repo6", branch, issueId) == Some(true))
|
||||
using(Git.open(repo6Dir)){ git =>
|
||||
createFile(git, s"refs/pull/${issueId}/head", "test.txt", "hoge4" )
|
||||
}
|
||||
service.checkConflictCache("user1", "repo1", branch, issueId) mustEqual None
|
||||
assert(service.checkConflictCache("user1", "repo6", branch, issueId) == None)
|
||||
}
|
||||
"conflicted cache invalid if origin branch moved" in {
|
||||
val repo1Dir = initRepository("user1","repo1")
|
||||
using(Git.open(repo1Dir)){ git =>
|
||||
it("conflicted cache invalid if origin branch moved") {
|
||||
val repo7Dir = initRepository("user1","repo7")
|
||||
using(Git.open(repo7Dir)){ git =>
|
||||
createConfrict(git)
|
||||
}
|
||||
service.checkConflict("user1", "repo1", branch, issueId) mustEqual true
|
||||
service.checkConflictCache("user1", "repo1", branch, issueId) mustEqual Some(true)
|
||||
using(Git.open(repo1Dir)){ git =>
|
||||
assert(service.checkConflict("user1", "repo7", branch, issueId) == true)
|
||||
assert(service.checkConflictCache("user1", "repo7", branch, issueId) == Some(true))
|
||||
using(Git.open(repo7Dir)){ git =>
|
||||
createFile(git, s"refs/heads/${branch}", "test.txt", "hoge4" )
|
||||
}
|
||||
service.checkConflictCache("user1", "repo1", branch, issueId) mustEqual None
|
||||
assert(service.checkConflictCache("user1", "repo7", branch, issueId) == None)
|
||||
}
|
||||
}
|
||||
"mergePullRequest" should {
|
||||
"can merge" in {
|
||||
val repo1Dir = initRepository("user1","repo1")
|
||||
using(Git.open(repo1Dir)){ git =>
|
||||
describe("mergePullRequest") {
|
||||
it("can merge") {
|
||||
val repo8Dir = initRepository("user1","repo8")
|
||||
using(Git.open(repo8Dir)){ git =>
|
||||
createFile(git, s"refs/pull/${issueId}/head", "test.txt", "hoge2" )
|
||||
val committer = new PersonIdent("dummy2", "dummy2@example.com")
|
||||
getFile(git, branch, "test.txt").content.get mustEqual "hoge"
|
||||
assert(getFile(git, branch, "test.txt").content.get == "hoge")
|
||||
val requestBranchId = git.getRepository.resolve(s"refs/pull/${issueId}/head")
|
||||
val masterId = git.getRepository.resolve(branch)
|
||||
service.mergePullRequest(git, branch, issueId, "merged", committer)
|
||||
val lastCommitId = git.getRepository.resolve(branch);
|
||||
val lastCommitId = git.getRepository.resolve(branch)
|
||||
val commit = using(new RevWalk(git.getRepository))(_.parseCommit(lastCommitId))
|
||||
commit.getCommitterIdent() mustEqual committer
|
||||
commit.getAuthorIdent() mustEqual committer
|
||||
commit.getFullMessage() mustEqual "merged"
|
||||
commit.getParents.toSet mustEqual Set( requestBranchId, masterId )
|
||||
getFile(git, branch, "test.txt").content.get mustEqual "hoge2"
|
||||
assert(commit.getCommitterIdent() == committer)
|
||||
assert(commit.getAuthorIdent() == committer)
|
||||
assert(commit.getFullMessage() == "merged")
|
||||
assert(commit.getParents.toSet == Set( requestBranchId, masterId ))
|
||||
assert(getFile(git, branch, "test.txt").content.get == "hoge2")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,189 @@
|
||||
package gitbucket.core.service
|
||||
|
||||
import gitbucket.core.util.GitSpecUtil._
|
||||
import org.eclipse.jgit.transport.{ReceivePack, ReceiveCommand}
|
||||
import org.eclipse.jgit.lib.ObjectId
|
||||
import gitbucket.core.model.CommitState
|
||||
import gitbucket.core.service.ProtectedBranchService.{ProtectedBranchReceiveHook, ProtectedBranchInfo}
|
||||
import org.scalatest.FunSpec
|
||||
|
||||
class ProtectedBranchServiceSpec extends FunSpec with ServiceSpecBase with ProtectedBranchService with CommitStatusService {
|
||||
|
||||
val receiveHook = new ProtectedBranchReceiveHook()
|
||||
val now = new java.util.Date()
|
||||
val sha = "0c77148632618b59b6f70004e3084002be2b8804"
|
||||
val sha2 = "0c77148632618b59b6f70004e3084002be2b8805"
|
||||
|
||||
describe("getProtectedBranchInfo") {
|
||||
it("should empty is disabled") {
|
||||
withTestDB { implicit session =>
|
||||
assert(getProtectedBranchInfo("user1", "repo1", "branch") == ProtectedBranchInfo.disabled("user1", "repo1"))
|
||||
}
|
||||
}
|
||||
it("should enable and update and disable") {
|
||||
withTestDB { implicit session =>
|
||||
generateNewUserWithDBRepository("user1", "repo1")
|
||||
enableBranchProtection("user1", "repo1", "branch", false, Nil)
|
||||
assert(getProtectedBranchInfo("user1", "repo1", "branch") == ProtectedBranchInfo("user1", "repo1", true, Nil, false))
|
||||
enableBranchProtection("user1", "repo1", "branch", true, Seq("hoge","huge"))
|
||||
assert(getProtectedBranchInfo("user1", "repo1", "branch") == ProtectedBranchInfo("user1", "repo1", true, Seq("hoge","huge"), true))
|
||||
disableBranchProtection("user1", "repo1", "branch")
|
||||
assert(getProtectedBranchInfo("user1", "repo1", "branch") == ProtectedBranchInfo.disabled("user1", "repo1"))
|
||||
}
|
||||
}
|
||||
it("should empty contexts is no-include-administrators") {
|
||||
withTestDB { implicit session =>
|
||||
generateNewUserWithDBRepository("user1", "repo1")
|
||||
enableBranchProtection("user1", "repo1", "branch", false, Nil)
|
||||
assert(getProtectedBranchInfo("user1", "repo1", "branch").includeAdministrators == false)
|
||||
enableBranchProtection("user1", "repo1", "branch", true, Nil)
|
||||
assert(getProtectedBranchInfo("user1", "repo1", "branch").includeAdministrators == false)
|
||||
}
|
||||
}
|
||||
it("getProtectedBranchList") {
|
||||
withTestDB { implicit session =>
|
||||
generateNewUserWithDBRepository("user1", "repo1")
|
||||
enableBranchProtection("user1", "repo1", "branch", false, Nil)
|
||||
enableBranchProtection("user1", "repo1", "branch2", false, Seq("fuga"))
|
||||
enableBranchProtection("user1", "repo1", "branch3", true, Seq("hoge"))
|
||||
assert(getProtectedBranchList("user1", "repo1").toSet == Set("branch", "branch2", "branch3"))
|
||||
}
|
||||
}
|
||||
it("getBranchProtectedReason on force push from admin") {
|
||||
withTestDB { implicit session =>
|
||||
withTestRepository { git =>
|
||||
val rp = new ReceivePack(git.getRepository)
|
||||
rp.setAllowNonFastForwards(true)
|
||||
val rc = new ReceiveCommand(ObjectId.fromString(sha), ObjectId.fromString(sha2), "refs/heads/branch", ReceiveCommand.Type.UPDATE_NONFASTFORWARD)
|
||||
generateNewUserWithDBRepository("user1", "repo1")
|
||||
assert(receiveHook.preReceive("user1", "repo1", rp, rc, "user1") == None)
|
||||
enableBranchProtection("user1", "repo1", "branch", false, Nil)
|
||||
assert(receiveHook.preReceive("user1", "repo1", rp, rc, "user1") == Some("Cannot force-push to a protected branch"))
|
||||
}
|
||||
}
|
||||
}
|
||||
it("getBranchProtectedReason on force push from other") {
|
||||
withTestDB { implicit session =>
|
||||
withTestRepository { git =>
|
||||
val rp = new ReceivePack(git.getRepository)
|
||||
rp.setAllowNonFastForwards(true)
|
||||
val rc = new ReceiveCommand(ObjectId.fromString(sha), ObjectId.fromString(sha2), "refs/heads/branch", ReceiveCommand.Type.UPDATE_NONFASTFORWARD)
|
||||
generateNewUserWithDBRepository("user1", "repo1")
|
||||
assert(receiveHook.preReceive("user1", "repo1", rp, rc, "user2") == None)
|
||||
enableBranchProtection("user1", "repo1", "branch", false, Nil)
|
||||
assert(receiveHook.preReceive("user1", "repo1", rp, rc, "user2") == Some("Cannot force-push to a protected branch"))
|
||||
}
|
||||
}
|
||||
}
|
||||
it("getBranchProtectedReason check status on push from other") {
|
||||
withTestDB { implicit session =>
|
||||
withTestRepository { git =>
|
||||
val rp = new ReceivePack(git.getRepository)
|
||||
rp.setAllowNonFastForwards(false)
|
||||
val rc = new ReceiveCommand(ObjectId.fromString(sha), ObjectId.fromString(sha2), "refs/heads/branch", ReceiveCommand.Type.UPDATE)
|
||||
val user1 = generateNewUserWithDBRepository("user1", "repo1")
|
||||
assert(receiveHook.preReceive("user1", "repo1", rp, rc, "user2") == None)
|
||||
enableBranchProtection("user1", "repo1", "branch", false, Seq("must"))
|
||||
assert(receiveHook.preReceive("user1", "repo1", rp, rc, "user2") == Some("Required status check \"must\" is expected"))
|
||||
enableBranchProtection("user1", "repo1", "branch", false, Seq("must", "must2"))
|
||||
assert(receiveHook.preReceive("user1", "repo1", rp, rc, "user2") == Some("2 of 2 required status checks are expected"))
|
||||
createCommitStatus("user1", "repo1", sha2, "context", CommitState.SUCCESS, None, None, now, user1)
|
||||
assert(receiveHook.preReceive("user1", "repo1", rp, rc, "user2") == Some("2 of 2 required status checks are expected"))
|
||||
createCommitStatus("user1", "repo1", sha2, "must", CommitState.SUCCESS, None, None, now, user1)
|
||||
assert(receiveHook.preReceive("user1", "repo1", rp, rc, "user2") == Some("Required status check \"must2\" is expected"))
|
||||
createCommitStatus("user1", "repo1", sha2, "must2", CommitState.SUCCESS, None, None, now, user1)
|
||||
assert(receiveHook.preReceive("user1", "repo1", rp, rc, "user2") == None)
|
||||
}
|
||||
}
|
||||
}
|
||||
it("getBranchProtectedReason check status on push from admin") {
|
||||
withTestDB { implicit session =>
|
||||
withTestRepository { git =>
|
||||
val rp = new ReceivePack(git.getRepository)
|
||||
rp.setAllowNonFastForwards(false)
|
||||
val rc = new ReceiveCommand(ObjectId.fromString(sha), ObjectId.fromString(sha2), "refs/heads/branch", ReceiveCommand.Type.UPDATE)
|
||||
val user1 = generateNewUserWithDBRepository("user1", "repo1")
|
||||
assert(receiveHook.preReceive("user1", "repo1", rp, rc, "user1") == None)
|
||||
enableBranchProtection("user1", "repo1", "branch", false, Seq("must"))
|
||||
assert(receiveHook.preReceive("user1", "repo1", rp, rc, "user1") == None)
|
||||
enableBranchProtection("user1", "repo1", "branch", true, Seq("must"))
|
||||
assert(receiveHook.preReceive("user1", "repo1", rp, rc, "user1") == Some("Required status check \"must\" is expected"))
|
||||
enableBranchProtection("user1", "repo1", "branch", false, Seq("must", "must2"))
|
||||
assert(receiveHook.preReceive("user1", "repo1", rp, rc, "user1") == None)
|
||||
enableBranchProtection("user1", "repo1", "branch", true, Seq("must", "must2"))
|
||||
assert(receiveHook.preReceive("user1", "repo1", rp, rc, "user1") == Some("2 of 2 required status checks are expected"))
|
||||
createCommitStatus("user1", "repo1", sha2, "context", CommitState.SUCCESS, None, None, now, user1)
|
||||
assert(receiveHook.preReceive("user1", "repo1", rp, rc, "user1") == Some("2 of 2 required status checks are expected"))
|
||||
createCommitStatus("user1", "repo1", sha2, "must", CommitState.SUCCESS, None, None, now, user1)
|
||||
assert(receiveHook.preReceive("user1", "repo1", rp, rc, "user1") == Some("Required status check \"must2\" is expected"))
|
||||
createCommitStatus("user1", "repo1", sha2, "must2", CommitState.SUCCESS, None, None, now, user1)
|
||||
assert(receiveHook.preReceive("user1", "repo1", rp, rc, "user1") == None)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
describe("ProtectedBranchInfo") {
|
||||
it("administrator is owner") {
|
||||
withTestDB { implicit session =>
|
||||
generateNewUserWithDBRepository("user1", "repo1")
|
||||
val x = ProtectedBranchInfo("user1", "repo1", true, Nil, false)
|
||||
assert(x.isAdministrator("user1") == true)
|
||||
assert(x.isAdministrator("user2") == false)
|
||||
}
|
||||
}
|
||||
it("administrator is manager") {
|
||||
withTestDB { implicit session =>
|
||||
val x = ProtectedBranchInfo("grp1", "repo1", true, Nil, false)
|
||||
x.createGroup("grp1", None, None)
|
||||
generateNewAccount("user1")
|
||||
generateNewAccount("user2")
|
||||
generateNewAccount("user3")
|
||||
|
||||
x.updateGroupMembers("grp1", List("user1"->true, "user2"->false))
|
||||
assert(x.isAdministrator("user1") == true)
|
||||
assert(x.isAdministrator("user2") == false)
|
||||
assert(x.isAdministrator("user3") == false)
|
||||
}
|
||||
}
|
||||
it("unSuccessedContexts") {
|
||||
withTestDB { implicit session =>
|
||||
val user1 = generateNewUserWithDBRepository("user1", "repo1")
|
||||
val x = ProtectedBranchInfo("user1", "repo1", true, List("must"), false)
|
||||
assert(x.unSuccessedContexts(sha) == Set("must"))
|
||||
createCommitStatus("user1", "repo1", sha, "context", CommitState.SUCCESS, None, None, now, user1)
|
||||
assert(x.unSuccessedContexts(sha) == Set("must"))
|
||||
createCommitStatus("user1", "repo1", sha, "must", CommitState.ERROR, None, None, now, user1)
|
||||
assert(x.unSuccessedContexts(sha) == Set("must"))
|
||||
createCommitStatus("user1", "repo1", sha, "must", CommitState.PENDING, None, None, now, user1)
|
||||
assert(x.unSuccessedContexts(sha) == Set("must"))
|
||||
createCommitStatus("user1", "repo1", sha, "must", CommitState.FAILURE, None, None, now, user1)
|
||||
assert(x.unSuccessedContexts(sha) == Set("must"))
|
||||
createCommitStatus("user1", "repo1", sha, "must", CommitState.SUCCESS, None, None, now, user1)
|
||||
assert(x.unSuccessedContexts(sha) == Set())
|
||||
}
|
||||
}
|
||||
it("unSuccessedContexts when empty") {
|
||||
withTestDB { implicit session =>
|
||||
val user1 = generateNewUserWithDBRepository("user1", "repo1")
|
||||
val x = ProtectedBranchInfo("user1", "repo1", true, Nil, false)
|
||||
val sha = "0c77148632618b59b6f70004e3084002be2b8804"
|
||||
assert(x.unSuccessedContexts(sha) == Set())
|
||||
createCommitStatus("user1", "repo1", sha, "context", CommitState.SUCCESS, None, None, now, user1)
|
||||
assert(x.unSuccessedContexts(sha) == Set())
|
||||
}
|
||||
}
|
||||
it("if disabled, needStatusCheck is false") {
|
||||
withTestDB { implicit session =>
|
||||
assert(ProtectedBranchInfo("user1", "repo1", false, Seq("must"), true).needStatusCheck("user1") == false)
|
||||
}
|
||||
}
|
||||
it("needStatusCheck includeAdministrators") {
|
||||
withTestDB { implicit session =>
|
||||
assert(ProtectedBranchInfo("user1", "repo1", true, Seq("must"), false).needStatusCheck("user2") == true)
|
||||
assert(ProtectedBranchInfo("user1", "repo1", true, Seq("must"), false).needStatusCheck("user1") == false)
|
||||
assert(ProtectedBranchInfo("user1", "repo1", true, Seq("must"), true ).needStatusCheck("user2") == true)
|
||||
assert(ProtectedBranchInfo("user1", "repo1", true, Seq("must"), true ).needStatusCheck("user1") == true)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,17 +1,18 @@
|
||||
package gitbucket.core.service
|
||||
|
||||
import gitbucket.core.model._
|
||||
import gitbucket.core.model.Profile._
|
||||
import org.scalatest.FunSpec
|
||||
|
||||
import org.specs2.mutable.Specification
|
||||
class PullRequestServiceSpec extends FunSpec with ServiceSpecBase
|
||||
with PullRequestService with IssuesService with AccountService with RepositoryService with CommitsService {
|
||||
|
||||
class PullRequestServiceSpec extends Specification with ServiceSpecBase with PullRequestService with IssuesService {
|
||||
def swap(r: (Issue, PullRequest)) = (r._2 -> r._1)
|
||||
"PullRequestService.getPullRequestFromBranch" should {
|
||||
"""
|
||||
|
||||
describe("PullRequestService.getPullRequestFromBranch") {
|
||||
it("""should
|
||||
|return pull request if exists pull request from `branch` to `defaultBranch` and not closed.
|
||||
|return pull request if exists pull request from `branch` to othre branch and not closed.
|
||||
|return None if all pull request is closed""".stripMargin.trim in { withTestDB { implicit se =>
|
||||
|return None if all pull request is closed""".stripMargin.trim) { withTestDB { implicit se =>
|
||||
generateNewUserWithDBRepository("user1", "repo1")
|
||||
generateNewUserWithDBRepository("user1", "repo2")
|
||||
generateNewUserWithDBRepository("user2", "repo1")
|
||||
@@ -22,12 +23,12 @@ class PullRequestServiceSpec extends Specification with ServiceSpecBase with Pul
|
||||
val r1 = swap(generateNewPullRequest("user1/repo1/master2", "user1/repo1/head1"))
|
||||
val r2 = swap(generateNewPullRequest("user1/repo1/master", "user1/repo1/head1"))
|
||||
val r3 = swap(generateNewPullRequest("user1/repo1/master4", "user1/repo1/head1"))
|
||||
getPullRequestFromBranch("user1", "repo1", "head1", "master") must_== Some(r2)
|
||||
assert(getPullRequestFromBranch("user1", "repo1", "head1", "master") == Some(r2))
|
||||
updateClosed("user1", "repo1", r2._1.issueId, true)
|
||||
getPullRequestFromBranch("user1", "repo1", "head1", "master").get must beOneOf(r1, r2)
|
||||
assert(Seq(r1, r2).contains(getPullRequestFromBranch("user1", "repo1", "head1", "master").get))
|
||||
updateClosed("user1", "repo1", r1._1.issueId, true)
|
||||
updateClosed("user1", "repo1", r3._1.issueId, true)
|
||||
getPullRequestFromBranch("user1", "repo1", "head1", "master") must beNone
|
||||
assert(getPullRequestFromBranch("user1", "repo1", "head1", "master") == None)
|
||||
} }
|
||||
}
|
||||
}
|
||||
@@ -1,35 +1,33 @@
|
||||
package gitbucket.core.service
|
||||
|
||||
import gitbucket.core.model._
|
||||
import gitbucket.core.model.Profile._
|
||||
import org.scalatest.FunSuite
|
||||
|
||||
import org.specs2.mutable.Specification
|
||||
class RepositoryServiceSpec extends FunSuite with ServiceSpecBase with RepositoryService with AccountService{
|
||||
test("renameRepository can rename CommitState, ProtectedBranches") { withTestDB { implicit session =>
|
||||
val tester = generateNewAccount("tester")
|
||||
insertRepository("repo", "root", None, false)
|
||||
val service = new CommitStatusService with ProtectedBranchService {}
|
||||
val id = service.createCommitStatus(
|
||||
userName = "root",
|
||||
repositoryName = "repo",
|
||||
sha = "0e97b8f59f7cdd709418bb59de53f741fd1c1bd7",
|
||||
context = "jenkins/test",
|
||||
state = CommitState.PENDING,
|
||||
targetUrl = Some("http://example.com/target"),
|
||||
description = Some("description"),
|
||||
creator = tester,
|
||||
now = new java.util.Date)
|
||||
|
||||
service.enableBranchProtection("root", "repo", "branch", true, Seq("must1", "must2"))
|
||||
|
||||
class RepositoryServiceSpec extends Specification with ServiceSpecBase with RepositoryService with AccountService{
|
||||
"RepositoryService" should {
|
||||
"renameRepository can rename CommitState" in { withTestDB { implicit session =>
|
||||
val tester = generateNewAccount("tester")
|
||||
createRepository("repo","root",None,false)
|
||||
val commitStatusService = new CommitStatusService{}
|
||||
val id = commitStatusService.createCommitStatus(
|
||||
userName = "root",
|
||||
repositoryName = "repo",
|
||||
sha = "0e97b8f59f7cdd709418bb59de53f741fd1c1bd7",
|
||||
context = "jenkins/test",
|
||||
state = CommitState.PENDING,
|
||||
targetUrl = Some("http://example.com/target"),
|
||||
description = Some("description"),
|
||||
creator = tester,
|
||||
now = new java.util.Date)
|
||||
val org = commitStatusService.getCommitStatus("root","repo", id).get
|
||||
renameRepository("root","repo","tester","repo2")
|
||||
val neo = commitStatusService.getCommitStatus("tester","repo2", org.commitId, org.context).get
|
||||
neo must_==
|
||||
org.copy(
|
||||
commitStatusId=neo.commitStatusId,
|
||||
repositoryName="repo2",
|
||||
userName="tester")
|
||||
}}
|
||||
}
|
||||
val orgPbi = service.getProtectedBranchInfo("root", "repo", "branch")
|
||||
val org = service.getCommitStatus("root","repo", id).get
|
||||
|
||||
renameRepository("root","repo","tester","repo2")
|
||||
|
||||
val neo = service.getCommitStatus("tester","repo2", org.commitId, org.context).get
|
||||
assert(neo == org.copy(commitStatusId = neo.commitStatusId, repositoryName = "repo2", userName = "tester"))
|
||||
assert(service.getProtectedBranchInfo("tester", "repo2", "branch") == orgPbi.copy(owner = "tester", repository = "repo2"))
|
||||
}}
|
||||
}
|
||||
|
||||
@@ -1,10 +1,13 @@
|
||||
package gitbucket.core.service
|
||||
|
||||
import gitbucket.core.servlet.AutoUpdate
|
||||
import gitbucket.core.util.{ControlUtil, DatabaseConfig, FileUtil}
|
||||
import gitbucket.core.GitBucketCoreModule
|
||||
import gitbucket.core.util.{DatabaseConfig, FileUtil}
|
||||
import gitbucket.core.util.ControlUtil._
|
||||
import gitbucket.core.model._
|
||||
import gitbucket.core.model.Profile._
|
||||
import io.github.gitbucket.solidbase.Solidbase
|
||||
import liquibase.database.core.H2Database
|
||||
import liquibase.database.jvm.JdbcConnection
|
||||
import profile.simple._
|
||||
|
||||
import org.apache.commons.io.FileUtils
|
||||
@@ -22,7 +25,10 @@ trait ServiceSpecBase {
|
||||
val (url, user, pass) = (DatabaseConfig.url(Some(dir.toString)), DatabaseConfig.user, DatabaseConfig.password)
|
||||
org.h2.Driver.load()
|
||||
using(DriverManager.getConnection(url, user, pass)){ conn =>
|
||||
AutoUpdate.versions.reverse.foreach(_.update(conn, Thread.currentThread.getContextClassLoader))
|
||||
val solidbase = new Solidbase()
|
||||
val db = new H2Database()
|
||||
db.setConnection(new JdbcConnection(conn)) // TODO Remove setConnection in the future
|
||||
solidbase.migrate(conn, Thread.currentThread.getContextClassLoader, db, GitBucketCoreModule)
|
||||
}
|
||||
Database.forURL(url, user, pass).withSession { session =>
|
||||
action(session)
|
||||
@@ -38,16 +44,16 @@ trait ServiceSpecBase {
|
||||
def user(name:String)(implicit s:Session):Account = AccountService.getAccountByUserName(name).get
|
||||
|
||||
lazy val dummyService = new RepositoryService with AccountService with IssuesService with PullRequestService
|
||||
with CommitStatusService (){}
|
||||
with CommitsService with CommitStatusService with LabelsService (){}
|
||||
|
||||
def generateNewUserWithDBRepository(userName:String, repositoryName:String)(implicit s:Session):Account = {
|
||||
val ac = AccountService.getAccountByUserName(userName).getOrElse(generateNewAccount(userName))
|
||||
dummyService.createRepository(repositoryName, userName, None, false)
|
||||
dummyService.insertRepository(repositoryName, userName, None, false)
|
||||
ac
|
||||
}
|
||||
|
||||
def generateNewIssue(userName:String, repositoryName:String, loginUser:String="root")(implicit s:Session): Int = {
|
||||
dummyService.createIssue(
|
||||
dummyService.insertIssue(
|
||||
owner = userName,
|
||||
repository = repositoryName,
|
||||
loginUser = loginUser,
|
||||
|
||||
@@ -1,44 +1,79 @@
|
||||
package gitbucket.core.service
|
||||
|
||||
import org.specs2.mutable.Specification
|
||||
import gitbucket.core.model.WebHook
|
||||
import org.scalatest.FunSuite
|
||||
import gitbucket.core.model.WebHookContentType
|
||||
|
||||
|
||||
class WebHookServiceSpec extends Specification with ServiceSpecBase {
|
||||
lazy val service = new WebHookPullRequestService with AccountService with RepositoryService with PullRequestService with IssuesService
|
||||
class WebHookServiceSpec extends FunSuite with ServiceSpecBase {
|
||||
lazy val service = new WebHookPullRequestService with AccountService with RepositoryService with PullRequestService with IssuesService with CommitsService
|
||||
|
||||
"WebHookPullRequestService.getPullRequestsByRequestForWebhook" should {
|
||||
"find from request branch" in { withTestDB { implicit session =>
|
||||
val user1 = generateNewUserWithDBRepository("user1","repo1")
|
||||
val user2 = generateNewUserWithDBRepository("user2","repo2")
|
||||
val user3 = generateNewUserWithDBRepository("user3","repo3")
|
||||
val issueUser = user("root")
|
||||
val (issue1, pullreq1) = generateNewPullRequest("user1/repo1/master1", "user2/repo2/master2", loginUser="root")
|
||||
val (issue3, pullreq3) = generateNewPullRequest("user3/repo3/master3", "user2/repo2/master2", loginUser="root")
|
||||
val (issue32, pullreq32) = generateNewPullRequest("user3/repo3/master32", "user2/repo2/master2", loginUser="root")
|
||||
generateNewPullRequest("user2/repo2/master2", "user1/repo1/master2")
|
||||
service.addWebHookURL("user1", "repo1", "webhook1-1")
|
||||
service.addWebHookURL("user1", "repo1", "webhook1-2")
|
||||
service.addWebHookURL("user2", "repo2", "webhook2-1")
|
||||
service.addWebHookURL("user2", "repo2", "webhook2-2")
|
||||
service.addWebHookURL("user3", "repo3", "webhook3-1")
|
||||
service.addWebHookURL("user3", "repo3", "webhook3-2")
|
||||
test("WebHookPullRequestService.getPullRequestsByRequestForWebhook") { withTestDB { implicit session =>
|
||||
val user1 = generateNewUserWithDBRepository("user1","repo1")
|
||||
val user2 = generateNewUserWithDBRepository("user2","repo2")
|
||||
val user3 = generateNewUserWithDBRepository("user3","repo3")
|
||||
val issueUser = user("root")
|
||||
val (issue1, pullreq1) = generateNewPullRequest("user1/repo1/master1", "user2/repo2/master2", loginUser="root")
|
||||
val (issue3, pullreq3) = generateNewPullRequest("user3/repo3/master3", "user2/repo2/master2", loginUser="root")
|
||||
val (issue32, pullreq32) = generateNewPullRequest("user3/repo3/master32", "user2/repo2/master2", loginUser="root")
|
||||
generateNewPullRequest("user2/repo2/master2", "user1/repo1/master2")
|
||||
service.addWebHook("user1", "repo1", "webhook1-1", Set(WebHook.PullRequest), WebHookContentType.FORM, Some("key"))
|
||||
service.addWebHook("user1", "repo1", "webhook1-2", Set(WebHook.PullRequest), WebHookContentType.FORM, Some("key"))
|
||||
service.addWebHook("user2", "repo2", "webhook2-1", Set(WebHook.PullRequest), WebHookContentType.FORM, Some("key"))
|
||||
service.addWebHook("user2", "repo2", "webhook2-2", Set(WebHook.PullRequest), WebHookContentType.FORM, Some("key"))
|
||||
service.addWebHook("user3", "repo3", "webhook3-1", Set(WebHook.PullRequest), WebHookContentType.FORM, Some("key"))
|
||||
service.addWebHook("user3", "repo3", "webhook3-2", Set(WebHook.PullRequest), WebHookContentType.FORM, Some("key"))
|
||||
|
||||
service.getPullRequestsByRequestForWebhook("user1","repo1","master1") must_== Map.empty
|
||||
assert(service.getPullRequestsByRequestForWebhook("user1","repo1","master1") == Map.empty)
|
||||
|
||||
var r = service.getPullRequestsByRequestForWebhook("user2","repo2","master2").mapValues(_.map(_.url).toSet)
|
||||
val r = service.getPullRequestsByRequestForWebhook("user2","repo2","master2").mapValues(_.map(_.url).toSet)
|
||||
|
||||
r.size must_== 3
|
||||
r((issue1, issueUser, pullreq1, user1, user2)) must_== Set("webhook1-1","webhook1-2")
|
||||
r((issue3, issueUser, pullreq3, user3, user2)) must_== Set("webhook3-1","webhook3-2")
|
||||
r((issue32, issueUser, pullreq32, user3, user2)) must_== Set("webhook3-1","webhook3-2")
|
||||
assert(r.size == 3)
|
||||
assert(r((issue1, issueUser, pullreq1, user1, user2)) == Set("webhook1-1","webhook1-2"))
|
||||
assert(r((issue3, issueUser, pullreq3, user3, user2)) == Set("webhook3-1","webhook3-2"))
|
||||
assert(r((issue32, issueUser, pullreq32, user3, user2)) == Set("webhook3-1","webhook3-2"))
|
||||
|
||||
// when closed, it not founds.
|
||||
service.updateClosed("user1","repo1",issue1.issueId, true)
|
||||
// when closed, it not founds.
|
||||
service.updateClosed("user1","repo1",issue1.issueId, true)
|
||||
|
||||
var r2 = service.getPullRequestsByRequestForWebhook("user2","repo2","master2").mapValues(_.map(_.url).toSet)
|
||||
r2.size must_== 2
|
||||
r2((issue3, issueUser, pullreq3, user3, user2)) must_== Set("webhook3-1","webhook3-2")
|
||||
r2((issue32, issueUser, pullreq32, user3, user2)) must_== Set("webhook3-1","webhook3-2")
|
||||
} }
|
||||
}
|
||||
val r2 = service.getPullRequestsByRequestForWebhook("user2","repo2","master2").mapValues(_.map(_.url).toSet)
|
||||
assert(r2.size == 2)
|
||||
assert(r2((issue3, issueUser, pullreq3, user3, user2)) == Set("webhook3-1","webhook3-2"))
|
||||
assert(r2((issue32, issueUser, pullreq32, user3, user2)) == Set("webhook3-1","webhook3-2"))
|
||||
} }
|
||||
|
||||
test("add and get and update and delete") { withTestDB { implicit session =>
|
||||
val user1 = generateNewUserWithDBRepository("user1","repo1")
|
||||
val formType = WebHookContentType.FORM
|
||||
val jsonType = WebHookContentType.JSON
|
||||
service.addWebHook("user1", "repo1", "http://example.com", Set(WebHook.PullRequest), formType, Some("key"))
|
||||
assert(service.getWebHooks("user1", "repo1") == List((WebHook("user1","repo1","http://example.com", formType, Some("key")),Set(WebHook.PullRequest))))
|
||||
assert(service.getWebHook("user1", "repo1", "http://example.com") == Some((WebHook("user1","repo1","http://example.com", formType, Some("key")),Set(WebHook.PullRequest))))
|
||||
assert(service.getWebHooksByEvent("user1", "repo1", WebHook.PullRequest) == List((WebHook("user1","repo1","http://example.com", formType, Some("key")))))
|
||||
assert(service.getWebHooksByEvent("user1", "repo1", WebHook.Push) == Nil)
|
||||
assert(service.getWebHook("user1", "repo1", "http://example.com2") == None)
|
||||
assert(service.getWebHook("user2", "repo1", "http://example.com") == None)
|
||||
assert(service.getWebHook("user1", "repo2", "http://example.com") == None)
|
||||
service.updateWebHook("user1", "repo1", "http://example.com", Set(WebHook.Push, WebHook.Issues), jsonType, Some("key"))
|
||||
assert(service.getWebHook("user1", "repo1", "http://example.com") == Some((WebHook("user1","repo1","http://example.com", jsonType, Some("key")),Set(WebHook.Push, WebHook.Issues))))
|
||||
assert(service.getWebHooksByEvent("user1", "repo1", WebHook.PullRequest) == Nil)
|
||||
assert(service.getWebHooksByEvent("user1", "repo1", WebHook.Push) == List((WebHook("user1","repo1","http://example.com", jsonType, Some("key")))))
|
||||
service.deleteWebHook("user1", "repo1", "http://example.com")
|
||||
assert(service.getWebHook("user1", "repo1", "http://example.com") == None)
|
||||
} }
|
||||
|
||||
test("getWebHooks, getWebHooksByEvent") { withTestDB { implicit session =>
|
||||
val user1 = generateNewUserWithDBRepository("user1","repo1")
|
||||
val ctype = WebHookContentType.FORM
|
||||
service.addWebHook("user1", "repo1", "http://example.com/1", Set(WebHook.PullRequest), ctype, Some("key"))
|
||||
service.addWebHook("user1", "repo1", "http://example.com/2", Set(WebHook.Push), ctype, Some("key"))
|
||||
service.addWebHook("user1", "repo1", "http://example.com/3", Set(WebHook.PullRequest,WebHook.Push), ctype, Some("key"))
|
||||
assert(service.getWebHooks("user1", "repo1") == List(
|
||||
WebHook("user1","repo1","http://example.com/1", ctype, Some("key"))->Set(WebHook.PullRequest),
|
||||
WebHook("user1","repo1","http://example.com/2", ctype, Some("key"))->Set(WebHook.Push),
|
||||
WebHook("user1","repo1","http://example.com/3", ctype, Some("key"))->Set(WebHook.PullRequest,WebHook.Push)))
|
||||
assert(service.getWebHooksByEvent("user1", "repo1", WebHook.PullRequest) == List(
|
||||
WebHook("user1","repo1","http://example.com/1", ctype, Some("key")),
|
||||
WebHook("user1","repo1","http://example.com/3", ctype, Some("key"))))
|
||||
} }
|
||||
}
|
||||
Reference in New Issue
Block a user