diff --git a/.scalafmt.conf b/.scalafmt.conf index 0cf1ba1..a595ea1 100644 --- a/.scalafmt.conf +++ b/.scalafmt.conf @@ -3,7 +3,7 @@ maxColumn = 120 docstrings = JavaDoc -align = true +align.tokens = ["%", "%%", {code = "=>", owner = "Case"}] align.openParenCallSite = false align.openParenDefnSite = false continuationIndent.callSite = 2 diff --git a/.travis.yml b/.travis.yml index dc863a8..3d96ee3 100644 --- a/.travis.yml +++ b/.travis.yml @@ -3,7 +3,7 @@ jdk: - oraclejdk8 script: - - sbt test + - sbt scalafmtSbtCheck scalafmtCheck test:scalafmtCheck test before_script: - sudo /etc/init.d/mysql stop - sudo /etc/init.d/postgresql stop diff --git a/build.sbt b/build.sbt index 7364294..56ef792 100644 --- a/build.sbt +++ b/build.sbt @@ -7,9 +7,10 @@ val ScalatraVersion = "2.6.1" val JettyVersion = "9.4.7.v20170914" -lazy val root = (project in file(".")).enablePlugins(SbtTwirl, ScalatraPlugin, JRebelPlugin).settings( - -) +lazy val root = (project in file(".")) + .enablePlugins(SbtTwirl, ScalatraPlugin, JRebelPlugin) + .settings( + ) sourcesInBase := false organization := Organization @@ -29,45 +30,45 @@ ) libraryDependencies ++= Seq( - "org.eclipse.jgit" % "org.eclipse.jgit.http.server" % "4.11.0.201803080745-r", - "org.eclipse.jgit" % "org.eclipse.jgit.archive" % "4.11.0.201803080745-r", - "org.scalatra" %% "scalatra" % ScalatraVersion, - "org.scalatra" %% "scalatra-json" % ScalatraVersion, - "org.scalatra" %% "scalatra-forms" % ScalatraVersion, - "org.json4s" %% "json4s-jackson" % "3.5.3", - "commons-io" % "commons-io" % "2.6", - "io.github.gitbucket" % "solidbase" % "1.0.2", - "io.github.gitbucket" % "markedj" % "1.0.15", - "org.apache.commons" % "commons-compress" % "1.15", - "org.apache.commons" % "commons-email" % "1.5", - "org.apache.httpcomponents" % "httpclient" % "4.5.4", - "org.apache.sshd" % "apache-sshd" % "1.6.0" exclude("org.slf4j","slf4j-jdk14"), - "org.apache.tika" % "tika-core" % "1.17", - "com.github.takezoe" %% "blocking-slick-32" % "0.0.10", - "com.novell.ldap" % "jldap" % "2009-10-07", - "com.h2database" % "h2" % "1.4.196", - "org.mariadb.jdbc" % "mariadb-java-client" % "2.2.3", - "org.postgresql" % "postgresql" % "42.1.4", - "ch.qos.logback" % "logback-classic" % "1.2.3", - "com.zaxxer" % "HikariCP" % "2.7.4", - "com.typesafe" % "config" % "1.3.2", - "com.typesafe.akka" %% "akka-actor" % "2.5.8", - "fr.brouillard.oss.security.xhub" % "xhub4j-core" % "1.0.0", - "com.github.bkromhout" % "java-diff-utils" % "2.1.1", - "org.cache2k" % "cache2k-all" % "1.0.1.Final", - "com.enragedginger" %% "akka-quartz-scheduler" % "1.6.1-akka-2.5.x" exclude("c3p0","c3p0"), - "net.coobird" % "thumbnailator" % "0.4.8", - "com.github.zafarkhaja" % "java-semver" % "0.9.0", - "com.nimbusds" % "oauth2-oidc-sdk" % "5.45", - "org.eclipse.jetty" % "jetty-webapp" % JettyVersion % "provided", - "javax.servlet" % "javax.servlet-api" % "3.1.0" % "provided", - "junit" % "junit" % "4.12" % "test", - "org.scalatra" %% "scalatra-scalatest" % ScalatraVersion % "test", - "org.mockito" % "mockito-core" % "2.13.0" % "test", - "com.wix" % "wix-embedded-mysql" % "3.0.0" % "test", - "ru.yandex.qatools.embed" % "postgresql-embedded" % "2.6" % "test", - "net.i2p.crypto" % "eddsa" % "0.2.0", - "is.tagomor.woothee" % "woothee-java" % "1.7.0" + "org.eclipse.jgit" % "org.eclipse.jgit.http.server" % "4.11.0.201803080745-r", + "org.eclipse.jgit" % "org.eclipse.jgit.archive" % "4.11.0.201803080745-r", + "org.scalatra" %% "scalatra" % ScalatraVersion, + "org.scalatra" %% "scalatra-json" % ScalatraVersion, + "org.scalatra" %% "scalatra-forms" % ScalatraVersion, + "org.json4s" %% "json4s-jackson" % "3.5.3", + "commons-io" % "commons-io" % "2.6", + "io.github.gitbucket" % "solidbase" % "1.0.2", + "io.github.gitbucket" % "markedj" % "1.0.15", + "org.apache.commons" % "commons-compress" % "1.15", + "org.apache.commons" % "commons-email" % "1.5", + "org.apache.httpcomponents" % "httpclient" % "4.5.4", + "org.apache.sshd" % "apache-sshd" % "1.6.0" exclude ("org.slf4j", "slf4j-jdk14"), + "org.apache.tika" % "tika-core" % "1.17", + "com.github.takezoe" %% "blocking-slick-32" % "0.0.10", + "com.novell.ldap" % "jldap" % "2009-10-07", + "com.h2database" % "h2" % "1.4.196", + "org.mariadb.jdbc" % "mariadb-java-client" % "2.2.3", + "org.postgresql" % "postgresql" % "42.1.4", + "ch.qos.logback" % "logback-classic" % "1.2.3", + "com.zaxxer" % "HikariCP" % "2.7.4", + "com.typesafe" % "config" % "1.3.2", + "com.typesafe.akka" %% "akka-actor" % "2.5.8", + "fr.brouillard.oss.security.xhub" % "xhub4j-core" % "1.0.0", + "com.github.bkromhout" % "java-diff-utils" % "2.1.1", + "org.cache2k" % "cache2k-all" % "1.0.1.Final", + "com.enragedginger" %% "akka-quartz-scheduler" % "1.6.1-akka-2.5.x" exclude ("c3p0", "c3p0"), + "net.coobird" % "thumbnailator" % "0.4.8", + "com.github.zafarkhaja" % "java-semver" % "0.9.0", + "com.nimbusds" % "oauth2-oidc-sdk" % "5.45", + "org.eclipse.jetty" % "jetty-webapp" % JettyVersion % "provided", + "javax.servlet" % "javax.servlet-api" % "3.1.0" % "provided", + "junit" % "junit" % "4.12" % "test", + "org.scalatra" %% "scalatra-scalatest" % ScalatraVersion % "test", + "org.mockito" % "mockito-core" % "2.13.0" % "test", + "com.wix" % "wix-embedded-mysql" % "3.0.0" % "test", + "ru.yandex.qatools.embed" % "postgresql-embedded" % "2.6" % "test", + "net.i2p.crypto" % "eddsa" % "0.2.0", + "is.tagomor.woothee" % "woothee-java" % "1.7.0" ) // Compiler settings @@ -78,7 +79,7 @@ // Test settings //testOptions in Test += Tests.Argument("-l", "ExternalDBTest") javaOptions in Test += "-Dgitbucket.home=target/gitbucket_home_for_test" -testOptions in Test += Tests.Setup( () => new java.io.File("target/gitbucket_home_for_test").mkdir() ) +testOptions in Test += Tests.Setup(() => new java.io.File("target/gitbucket_home_for_test").mkdir()) fork in Test := true // Packaging options @@ -88,9 +89,9 @@ test in assembly := {} assemblyMergeStrategy in assembly := { case PathList("META-INF", xs @ _*) => - (xs map {_.toLowerCase}) match { + (xs map { _.toLowerCase }) match { case ("manifest.mf" :: Nil) => MergeStrategy.discard - case _ => MergeStrategy.discard + case _ => MergeStrategy.discard } case x => MergeStrategy.first } @@ -112,7 +113,9 @@ // Exclude a war file from published artifacts signedArtifacts := { - signedArtifacts.value.filterNot { case (_, file) => file.getName.endsWith(".war") || file.getName.endsWith(".war.asc") } + signedArtifacts.value.filterNot { + case (_, file) => file.getName.endsWith(".war") || file.getName.endsWith(".war.asc") + } } // Create executable war file @@ -135,32 +138,31 @@ import java.util.jar.Attributes.{Name => AttrName} import java.util.jar.{Manifest => JarManifest} - val workDir = Keys.target.value / "executable" - val warName = Keys.name.value + ".war" + val workDir = Keys.target.value / "executable" + val warName = Keys.name.value + ".war" - val log = streams.value.log + val log = streams.value.log log info s"building executable webapp in ${workDir}" // initialize temp directory - val temp = workDir / "webapp" + val temp = workDir / "webapp" IO delete temp // include jetty classes val jettyJars = Keys.update.value select configurationFilter(name = ExecutableConfig.name) jettyJars foreach { jar => - IO unzip (jar, temp, (name:String) => + IO unzip (jar, temp, (name: String) => (name startsWith "javax/") || - (name startsWith "org/") - ) + (name startsWith "org/")) } // include original war file - val warFile = (Keys.`package`).value + val warFile = (Keys.`package`).value IO unzip (warFile, temp) // include launcher classes - val classDir = (Keys.classDirectory in Compile).value - val launchClasses = Seq("JettyLauncher.class" /*, "HttpsSupportConnector.class" */) + val classDir = (Keys.classDirectory in Compile).value + val launchClasses = Seq("JettyLauncher.class" /*, "HttpsSupportConnector.class" */ ) launchClasses foreach { name => IO copyFile (classDir / name, temp / name) } @@ -168,32 +170,34 @@ // include plugins val pluginsDir = temp / "WEB-INF" / "classes" / "plugins" IO createDirectory (pluginsDir) - IO copyFile(Keys.baseDirectory.value / "plugins.json", pluginsDir / "plugins.json") + IO copyFile (Keys.baseDirectory.value / "plugins.json", pluginsDir / "plugins.json") - val json = IO read(Keys.baseDirectory.value / "plugins.json") + val json = IO read (Keys.baseDirectory.value / "plugins.json") PluginsJson.getUrls(json).foreach { url => log info s"Download: ${url}" - IO transfer(new java.net.URL(url).openStream, pluginsDir / url.substring(url.lastIndexOf("/") + 1)) + IO transfer (new java.net.URL(url).openStream, pluginsDir / url.substring(url.lastIndexOf("/") + 1)) } // zip it up IO delete (temp / "META-INF" / "MANIFEST.MF") - val contentMappings = (temp.allPaths --- PathFinder(temp)).get pair { file => IO.relativizeFile(temp, file) } - val manifest = new JarManifest + val contentMappings = (temp.allPaths --- PathFinder(temp)).get pair { file => + IO.relativizeFile(temp, file) + } + val manifest = new JarManifest manifest.getMainAttributes put (AttrName.MANIFEST_VERSION, "1.0") - manifest.getMainAttributes put (AttrName.MAIN_CLASS, "JettyLauncher") - val outputFile = workDir / warName - IO jar (contentMappings.map { case (file, path) => (file, path.toString) } , outputFile, manifest) + manifest.getMainAttributes put (AttrName.MAIN_CLASS, "JettyLauncher") + val outputFile = workDir / warName + IO jar (contentMappings.map { case (file, path) => (file, path.toString) }, outputFile, manifest) // generate checksums Seq( - "md5" -> "MD5", - "sha1" -> "SHA-1", + "md5" -> "MD5", + "sha1" -> "SHA-1", "sha256" -> "SHA-256" - ) - .foreach { case (extension, algorithm) => - val checksumFile = workDir / (warName + "." + extension) - Checksums generate (outputFile, checksumFile, algorithm) + ).foreach { + case (extension, algorithm) => + val checksumFile = workDir / (warName + "." + extension) + Checksums generate (outputFile, checksumFile, algorithm) } // done @@ -203,10 +207,12 @@ publishTo := { val nexus = "https://oss.sonatype.org/" if (version.value.trim.endsWith("SNAPSHOT")) Some("snapshots" at nexus + "content/repositories/snapshots") - else Some("releases" at nexus + "service/local/staging/deploy/maven2") + else Some("releases" at nexus + "service/local/staging/deploy/maven2") } publishMavenStyle := true -pomIncludeRepository := { _ => false } +pomIncludeRepository := { _ => + false +} pomExtra := ( https://github.com/gitbucket/gitbucket diff --git a/project/Checksums.scala b/project/Checksums.scala index 0f4d52c..7dfe120 100644 --- a/project/Checksums.scala +++ b/project/Checksums.scala @@ -6,29 +6,31 @@ object Checksums { private val bufferSize = 2048 - def generate(source:File, target:File, algorithm:String):Unit = - sbt.IO write (target, compute(source, algorithm)) + def generate(source: File, target: File, algorithm: String): Unit = + sbt.IO write (target, compute(source, algorithm)) - def compute(file:File, algorithm:String):String = - hex(raw(file, algorithm)) + def compute(file: File, algorithm: String): String = + hex(raw(file, algorithm)) - def raw(file:File, algorithm:String):Array[Byte] = - (Using fileInputStream file) { is => - val md = MessageDigest getInstance algorithm - val buf = new Array[Byte](bufferSize) - md.reset() - @tailrec - def loop() { - val len = is read buf - if (len != -1) { - md update (buf, 0, len) - loop() - } + def raw(file: File, algorithm: String): Array[Byte] = + (Using fileInputStream file) { is => + val md = MessageDigest getInstance algorithm + val buf = new Array[Byte](bufferSize) + md.reset() + @tailrec + def loop() { + val len = is read buf + if (len != -1) { + md update (buf, 0, len) + loop() } - loop() - md.digest() } + loop() + md.digest() + } - def hex(bytes:Array[Byte]):String = - bytes map { it => "%02x" format (it.toInt & 0xff) } mkString "" + def hex(bytes: Array[Byte]): String = + bytes map { it => + "%02x" format (it.toInt & 0xff) + } mkString "" } diff --git a/project/PluginsJson.scala b/project/PluginsJson.scala index dbf6ab1..f7355c1 100644 --- a/project/PluginsJson.scala +++ b/project/PluginsJson.scala @@ -13,4 +13,3 @@ } } - diff --git a/project/plugins.sbt b/project/plugins.sbt index 3240439..d0a6b26 100644 --- a/project/plugins.sbt +++ b/project/plugins.sbt @@ -1,11 +1,11 @@ scalacOptions ++= Seq("-unchecked", "-deprecation", "-feature") -addSbtPlugin("com.geirsson" % "sbt-scalafmt" % "1.4.0") -addSbtPlugin("com.typesafe.sbt" % "sbt-twirl" % "1.3.13") -addSbtPlugin("com.eed3si9n" % "sbt-assembly" % "0.14.5") +addSbtPlugin("com.geirsson" % "sbt-scalafmt" % "1.4.0") +addSbtPlugin("com.typesafe.sbt" % "sbt-twirl" % "1.3.13") +addSbtPlugin("com.eed3si9n" % "sbt-assembly" % "0.14.5") //addSbtPlugin("com.earldouglas" % "xsbt-web-plugin" % "4.0.0") //addSbtPlugin("fi.gekkio.sbtplugins" % "sbt-jrebel-plugin" % "0.10.0") -addSbtPlugin("org.scalatra.sbt" % "sbt-scalatra" % "1.0.1") -addSbtPlugin("com.jsuereth" % "sbt-pgp" % "1.1.0") +addSbtPlugin("org.scalatra.sbt" % "sbt-scalatra" % "1.0.1") +addSbtPlugin("com.jsuereth" % "sbt-pgp" % "1.1.0") addSbtCoursier -addSbtPlugin("com.typesafe.sbt" % "sbt-license-report" % "1.2.0") +addSbtPlugin("com.typesafe.sbt" % "sbt-license-report" % "1.2.0") diff --git a/src/test/scala/gitbucket/core/GitBucketCoreModuleSpec.scala b/src/test/scala/gitbucket/core/GitBucketCoreModuleSpec.scala index 449e8db..264778f 100644 --- a/src/test/scala/gitbucket/core/GitBucketCoreModuleSpec.scala +++ b/src/test/scala/gitbucket/core/GitBucketCoreModuleSpec.scala @@ -19,7 +19,7 @@ class GitBucketCoreModuleSpec extends FunSuite { - test("Migration H2"){ + test("Migration H2") { new Solidbase().migrate( DriverManager.getConnection("jdbc:h2:mem:test", "sa", "sa"), Thread.currentThread().getContextClassLoader(), @@ -28,7 +28,7 @@ ) } - test("Migration MySQL", ExternalDBTest){ + test("Migration MySQL", ExternalDBTest) { val config = aMysqldConfig(v5_7_latest) .withPort(3306) .withUser("sa", "sa") @@ -53,14 +53,15 @@ } } - test("Migration PostgreSQL", ExternalDBTest){ + test("Migration PostgreSQL", ExternalDBTest) { val runtime = PostgresStarter.getDefaultInstance() val config = new PostgresConfig( PRODUCTION, new Net("localhost", 5432), new Storage("gitbucket"), new Timeout(), - new Credentials("sa", "sa")) + new Credentials("sa", "sa") + ) val exec = runtime.prepare(config) val process = exec.start() diff --git a/src/test/scala/gitbucket/core/api/JsonFormatSpec.scala b/src/test/scala/gitbucket/core/api/JsonFormatSpec.scala index ccf6914..f5b0b80 100644 --- a/src/test/scala/gitbucket/core/api/JsonFormatSpec.scala +++ b/src/test/scala/gitbucket/core/api/JsonFormatSpec.scala @@ -8,14 +8,13 @@ import java.util.{Calendar, TimeZone, Date} - class JsonFormatSpec extends FunSuite { val date1 = { val d = Calendar.getInstance(TimeZone.getTimeZone("UTC")) - d.set(2011,3,14,16,0,49) + d.set(2011, 3, 14, 16, 0, 49) d.getTime } - def date(date:String): Date = { + def date(date: String): Date = { val f = new java.text.SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'") f.setTimeZone(TimeZone.getTimeZone("UTC")) f.parse(date) @@ -24,12 +23,8 @@ val repo1Name = RepositoryName("octocat/Hello-World") implicit val context = JsonFormat.Context("http://gitbucket.exmple.com", None) - val apiUser = ApiUser( - login = "octocat", - email = "octocat@example.com", - `type` = "User", - site_admin = false, - created_at = date1) + val apiUser = + ApiUser(login = "octocat", email = "octocat@example.com", `type` = "User", site_admin = false, created_at = date1) val apiUserJson = """{ "login":"octocat", "email":"octocat@example.com", @@ -49,7 +44,8 @@ forks = 0, `private` = false, default_branch = "master", - owner = apiUser)(urlIsHtmlUrl = false) + owner = apiUser + )(urlIsHtmlUrl = false) val repositoryJson = s"""{ "name" : "Hello-World", "full_name" : "octocat/Hello-World", @@ -96,8 +92,9 @@ added = Nil, removed = Nil, modified = List("README.md"), - author = ApiPersonIdent("baxterthehacker","baxterthehacker@users.noreply.github.com",date1), - committer = ApiPersonIdent("baxterthehacker","baxterthehacker@users.noreply.github.com",date1))(RepositoryName("baxterthehacker", "public-repo"), true) + author = ApiPersonIdent("baxterthehacker", "baxterthehacker@users.noreply.github.com", date1), + committer = ApiPersonIdent("baxterthehacker", "baxterthehacker@users.noreply.github.com", date1) + )(RepositoryName("baxterthehacker", "public-repo"), true) val apiPushCommitJson = s"""{ "id": "0d1a26e67d8f5eaf1f6ba5c57fc3c7d91ac0fd1c", // "distinct": true, @@ -127,12 +124,11 @@ ] }""" - val apiComment = ApiComment( - id =1, - user = apiUser, - body= "Me too", - created_at= date1, - updated_at= date1)(RepositoryName("octocat","Hello-World"), 100, false) + val apiComment = ApiComment(id = 1, user = apiUser, body = "Me too", created_at = date1, updated_at = date1)( + RepositoryName("octocat", "Hello-World"), + 100, + false + ) val apiCommentJson = s"""{ "id": 1, "body": "Me too", @@ -142,12 +138,11 @@ "updated_at": "2011-04-14T16:00:49Z" }""" - val apiCommentPR = ApiComment( - id =1, - user = apiUser, - body= "Me too", - created_at= date1, - updated_at= date1)(RepositoryName("octocat","Hello-World"), 100, true) + val apiCommentPR = ApiComment(id = 1, user = apiUser, body = "Me too", created_at = date1, updated_at = date1)( + RepositoryName("octocat", "Hello-World"), + 100, + true + ) val apiCommentPRJson = s"""{ "id": 1, "body": "Me too", @@ -157,7 +152,7 @@ "updated_at": "2011-04-14T16:00:49Z" }""" - val apiPersonIdent = ApiPersonIdent("Monalisa Octocat","support@example.com",date1) + val apiPersonIdent = ApiPersonIdent("Monalisa Octocat", "support@example.com", date1) val apiPersonIdentJson = """ { "name": "Monalisa Octocat", "email": "support@example.com", @@ -167,13 +162,14 @@ val apiCommitListItem = ApiCommitListItem( sha = sha1, commit = ApiCommitListItem.Commit( - message = "Fix all the bugs", - author = apiPersonIdent, + message = "Fix all the bugs", + author = apiPersonIdent, committer = apiPersonIdent - )(sha1, repo1Name), + )(sha1, repo1Name), author = Some(apiUser), - committer= Some(apiUser), - parents= Seq(ApiCommitListItem.Parent("6dcb09b5b57875f334f61aebed695e2e4193db5e")(repo1Name)))(repo1Name) + committer = Some(apiUser), + parents = Seq(ApiCommitListItem.Parent("6dcb09b5b57875f334f61aebed695e2e4193db5e")(repo1Name)) + )(repo1Name) val apiCommitListItemJson = s"""{ "url": "${context.baseUrl}/api/v3/repos/octocat/Hello-World/commits/6dcb09b5b57875f334f61aebed695e2e4193db5e", "sha": "6dcb09b5b57875f334f61aebed695e2e4193db5e", @@ -198,7 +194,8 @@ sha = sha1, total_count = 2, statuses = List(apiCommitStatus), - repository = repository) + repository = repository + ) val apiCombinedCommitStatusJson = s"""{ "state": "success", "sha": "$sha1", @@ -208,9 +205,7 @@ "url": "${context.baseUrl}/api/v3/repos/octocat/Hello-World/commits/$sha1/status" }""" - val apiLabel = ApiLabel( - name = "bug", - color = "f29513")(RepositoryName("octocat","Hello-World")) + val apiLabel = ApiLabel(name = "bug", color = "f29513")(RepositoryName("octocat", "Hello-World")) val apiLabelJson = s"""{ "name": "bug", "color": "f29513", @@ -218,14 +213,15 @@ }""" val apiIssue = ApiIssue( - number = 1347, - title = "Found a bug", - user = apiUser, - labels = List(apiLabel), - state = "open", - body = "I'm having a problem with this.", - created_at = date1, - updated_at = date1)(RepositoryName("octocat","Hello-World"), false) + number = 1347, + title = "Found a bug", + user = apiUser, + labels = List(apiLabel), + state = "open", + body = "I'm having a problem with this.", + created_at = date1, + updated_at = date1 + )(RepositoryName("octocat", "Hello-World"), false) val apiIssueJson = s"""{ "number": 1347, "state": "open", @@ -240,14 +236,15 @@ }""" val apiIssuePR = ApiIssue( - number = 1347, - title = "Found a bug", - user = apiUser, - labels = List(apiLabel), - state = "open", - body = "I'm having a problem with this.", - created_at = date1, - updated_at = date1)(RepositoryName("octocat","Hello-World"), true) + number = 1347, + title = "Found a bug", + user = apiUser, + labels = List(apiLabel), + state = "open", + body = "I'm having a problem with this.", + created_at = date1, + updated_at = date1 + )(RepositoryName("octocat", "Hello-World"), true) val apiIssuePRJson = s"""{ "number": 1347, "state": "open", @@ -268,27 +265,21 @@ }""" val apiPullRequest = ApiPullRequest( - number = 1347, - state = "open", - updated_at = date1, - created_at = date1, - head = ApiPullRequest.Commit( - sha = sha1, - ref = "new-topic", - repo = repository)("octocat"), - base = ApiPullRequest.Commit( - sha = sha1, - ref = "master", - repo = repository)("octocat"), - mergeable = None, - merged = false, - merged_at = Some(date1), - merged_by = Some(apiUser), - title = "new-feature", - body = "Please pull these awesome changes", - user = apiUser, - labels = List(apiLabel), - assignee = Some(apiUser) + number = 1347, + state = "open", + updated_at = date1, + created_at = date1, + head = ApiPullRequest.Commit(sha = sha1, ref = "new-topic", repo = repository)("octocat"), + base = ApiPullRequest.Commit(sha = sha1, ref = "master", repo = repository)("octocat"), + mergeable = None, + merged = false, + merged_at = Some(date1), + merged_by = Some(apiUser), + title = "new-feature", + body = "Please pull these awesome changes", + user = apiUser, + labels = List(apiLabel), + assignee = Some(apiUser) ) val apiPullRequestJson = s"""{ @@ -342,12 +333,12 @@ // https://developer.github.com/v3/activity/events/types/#pullrequestreviewcommentevent val apiPullRequestReviewComment = ApiPullRequestReviewComment( id = 29724692, - // "diff_hunk": "@@ -1 +1 @@\n-# public-repo", + // "diff_hunk": "@@ -1 +1 @@\n-# public-repo", path = "README.md", - // "position": 1, - // "original_position": 1, + // "position": 1, + // "original_position": 1, commit_id = "0d1a26e67d8f5eaf1f6ba5c57fc3c7d91ac0fd1c", - // "original_commit_id": "0d1a26e67d8f5eaf1f6ba5c57fc3c7d91ac0fd1c", + // "original_commit_id": "0d1a26e67d8f5eaf1f6ba5c57fc3c7d91ac0fd1c", user = apiUser, body = "Maybe you should use more emojji on this line.", created_at = date("2015-05-05T23:40:27Z"), @@ -381,8 +372,10 @@ } }""" - - val apiBranchProtection = ApiBranchProtection(true, Some(ApiBranchProtection.Status(ApiBranchProtection.Everyone, Seq("continuous-integration/travis-ci")))) + val apiBranchProtection = ApiBranchProtection( + true, + Some(ApiBranchProtection.Status(ApiBranchProtection.Everyone, Seq("continuous-integration/travis-ci"))) + ) val apiBranchProtectionJson = """{ "enabled": true, "required_status_checks": { diff --git a/src/test/scala/gitbucket/core/model/CommitStateSpec.scala b/src/test/scala/gitbucket/core/model/CommitStateSpec.scala index 01a5909..4c63b4f 100644 --- a/src/test/scala/gitbucket/core/model/CommitStateSpec.scala +++ b/src/test/scala/gitbucket/core/model/CommitStateSpec.scala @@ -3,7 +3,6 @@ import gitbucket.core.model.CommitState._ import org.scalatest.FunSpec - class CommitStateSpec extends FunSpec { describe("CommitState") { it("should combine empty must eq PENDING") { diff --git a/src/test/scala/gitbucket/core/service/AccessTokenServiceSpec.scala b/src/test/scala/gitbucket/core/service/AccessTokenServiceSpec.scala index 45ab3ff..39fca81 100644 --- a/src/test/scala/gitbucket/core/service/AccessTokenServiceSpec.scala +++ b/src/test/scala/gitbucket/core/service/AccessTokenServiceSpec.scala @@ -8,72 +8,87 @@ class AccessTokenServiceSpec extends FunSuite with ServiceSpecBase { - test("generateAccessToken") { withTestDB { implicit session => - assert(AccessTokenService.generateAccessToken("root", "note") match { - case (id, token) => id != 0 - }) - }} - - test("getAccessTokens") { withTestDB { implicit session => - val (id, token) = AccessTokenService.generateAccessToken("root", "note") - val tokenHash = AccessTokenService.tokenToHash(token) - - assert(AccessTokenService.getAccessTokens("root") == List(AccessToken(`id`, "root", `tokenHash`, "note"))) - }} - - 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") - - assert(AccessTokenService.getAccessTokens("root") == List(AccessToken(`id`, "root", `tokenHash`, "note"))) - }} - - test("deleteAccessToken") { withTestDB { implicit session => - val (id, token) = AccessTokenService.generateAccessToken("root", "note") - val user2 = generateNewAccount("user2") - AccessTokenService.generateAccessToken("user2", "note2") - - AccessTokenService.deleteAccessToken("root", id) - - assert(AccessTokenService.getAccessTokens("root").isEmpty) - }} - - test("getAccountByAccessToken") { withTestDB { implicit session => - val (id, token) = AccessTokenService.generateAccessToken("root", "note") - assert(AccessTokenService.getAccountByAccessToken(token) match { - case Some(user) => user.userName == "root" - }) - }} - - 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)) - - assert(AccessTokenService.getAccountByAccessToken(token).isEmpty) - }} - - 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 + test("generateAccessToken") { + withTestDB { implicit session => + assert(AccessTokenService.generateAccessToken("root", "note") match { + case (id, token) => id != 0 + }) } + } - assert(service.generateAccessToken("root", "note1")._2 == "token1") - assert(service.generateAccessToken("root", "note2")._2 == "token2") - }} + test("getAccessTokens") { + withTestDB { implicit session => + val (id, token) = AccessTokenService.generateAccessToken("root", "note") + val tokenHash = AccessTokenService.tokenToHash(token) - test("when update Account.userName then AccessToken.userName changed") { withTestDB { implicit session => - val user2 = generateNewAccount("user2") - val (id, token) = AccessTokenService.generateAccessToken("user2", "note") + assert(AccessTokenService.getAccessTokens("root") == List(AccessToken(`id`, "root", `tokenHash`, "note"))) + } + } - Accounts.filter(_.userName === "user2".bind).map(_.userName).update("user3") + 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") - assert(AccessTokenService.getAccountByAccessToken(token) match { - case Some(user) => user.userName == "user3" - }) - }} + assert(AccessTokenService.getAccessTokens("root") == List(AccessToken(`id`, "root", `tokenHash`, "note"))) + } + } + + test("deleteAccessToken") { + withTestDB { implicit session => + val (id, token) = AccessTokenService.generateAccessToken("root", "note") + val user2 = generateNewAccount("user2") + AccessTokenService.generateAccessToken("user2", "note2") + + AccessTokenService.deleteAccessToken("root", id) + + assert(AccessTokenService.getAccessTokens("root").isEmpty) + } + } + + test("getAccountByAccessToken") { + withTestDB { implicit session => + val (id, token) = AccessTokenService.generateAccessToken("root", "note") + assert(AccessTokenService.getAccountByAccessToken(token) match { + case Some(user) => user.userName == "root" + }) + } + } + + 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)) + + assert(AccessTokenService.getAccountByAccessToken(token).isEmpty) + } + } + + 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 + } + + assert(service.generateAccessToken("root", "note1")._2 == "token1") + assert(service.generateAccessToken("root", "note2")._2 == "token2") + } + } + + test("when update Account.userName then AccessToken.userName changed") { + withTestDB { implicit session => + val user2 = generateNewAccount("user2") + val (id, token) = AccessTokenService.generateAccessToken("user2", "note") + + Accounts.filter(_.userName === "user2".bind).map(_.userName).update("user3") + + assert(AccessTokenService.getAccountByAccessToken(token) match { + case Some(user) => user.userName == "user3" + }) + } + } } - diff --git a/src/test/scala/gitbucket/core/service/AccountFederationServiceSpec.scala b/src/test/scala/gitbucket/core/service/AccountFederationServiceSpec.scala index 4f0fe2d..8e69ed9 100644 --- a/src/test/scala/gitbucket/core/service/AccountFederationServiceSpec.scala +++ b/src/test/scala/gitbucket/core/service/AccountFederationServiceSpec.scala @@ -7,7 +7,13 @@ 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")) + val actual = AccountFederationService.getOrCreateFederatedUser( + "someIssuer", + "someSubject", + "dummy@example.com", + Some("foo"), + Some("Foo") + ) assert(actual.get.userName == "foo") assert(actual.get.password == "[DUMMY]") assert(actual.get.fullName == "Foo") @@ -22,7 +28,13 @@ generateNewAccount("someUser") AccountFederationService.createAccountFederation("someIssuer", "someSubject", "someUser") - val actual = AccountFederationService.getOrCreateFederatedUser("someIssuer", "someSubject", "dummy@example.com", Some("dummy"), Some("dummy")) + val actual = AccountFederationService.getOrCreateFederatedUser( + "someIssuer", + "someSubject", + "dummy@example.com", + Some("dummy"), + Some("dummy") + ) assert(actual.get.userName == "someUser") } } @@ -32,7 +44,13 @@ AccountFederationService.createAccountFederation("someIssuer", "someSubject", "someUser") AccountService.updateAccount(user.copy(isRemoved = true)) - val actual = AccountFederationService.getOrCreateFederatedUser("someIssuer", "someSubject", "dummy@example.com", Some("dummy"), Some("dummy")) + val actual = AccountFederationService.getOrCreateFederatedUser( + "someIssuer", + "someSubject", + "dummy@example.com", + Some("dummy"), + Some("dummy") + ) assert(actual.isEmpty) } } diff --git a/src/test/scala/gitbucket/core/service/AccountServiceSpec.scala b/src/test/scala/gitbucket/core/service/AccountServiceSpec.scala index a4730cb..4162883 100644 --- a/src/test/scala/gitbucket/core/service/AccountServiceSpec.scala +++ b/src/test/scala/gitbucket/core/service/AccountServiceSpec.scala @@ -8,87 +8,103 @@ val RootMailAddress = "root@localhost" - test("getAllUsers") { withTestDB { implicit session => - assert(AccountService.getAllUsers() match { - case List(Account("root", "root", RootMailAddress, _, true, _, _, _, None, None, false, false, None)) => true - case _ => false - }) - }} + test("getAllUsers") { + withTestDB { implicit session => + assert(AccountService.getAllUsers() match { + case List(Account("root", "root", RootMailAddress, _, true, _, _, _, None, None, false, false, None)) => true + case _ => false + }) + } + } - test("getAccountByUserName") { withTestDB { implicit session => - assert(AccountService.getAccountByUserName("root").get.userName == "root") - assert(AccountService.getAccountByUserName("invalid user name").isEmpty) - }} + test("getAccountByUserName") { + withTestDB { implicit session => + assert(AccountService.getAccountByUserName("root").get.userName == "root") + assert(AccountService.getAccountByUserName("invalid user name").isEmpty) + } + } - test("getAccountByMailAddress") { withTestDB { implicit session => - assert(AccountService.getAccountByMailAddress(RootMailAddress).isDefined) - }} + test("getAccountByMailAddress") { + withTestDB { implicit session => + assert(AccountService.getAccountByMailAddress(RootMailAddress).isDefined) + } + } - test("updateLastLoginDate") { withTestDB { implicit session => - val root = "root" - def user() = AccountService.getAccountByUserName(root).getOrElse(sys.error(s"user $root does not exists")) + test("updateLastLoginDate") { + withTestDB { implicit session => + val root = "root" + def user() = AccountService.getAccountByUserName(root).getOrElse(sys.error(s"user $root does not exists")) - assert(user().lastLoginDate.isEmpty) + assert(user().lastLoginDate.isEmpty) - val date1 = new Date - AccountService.updateLastLoginDate(root) - assert(user().lastLoginDate.get.compareTo(date1) > 0) + val date1 = new Date + AccountService.updateLastLoginDate(root) + assert(user().lastLoginDate.get.compareTo(date1) > 0) - val date2 = new Date - Thread.sleep(1000) - AccountService.updateLastLoginDate(root) - assert(user().lastLoginDate.get.compareTo(date2) > 0) - }} + val date2 = new Date + Thread.sleep(1000) + AccountService.updateLastLoginDate(root) + assert(user().lastLoginDate.get.compareTo(date2) > 0) + } + } - test("updateAccount") { withTestDB { implicit session => - val root = "root" - def user() = AccountService.getAccountByUserName(root).getOrElse(sys.error(s"user $root does not exists")) + test("updateAccount") { + withTestDB { implicit session => + val root = "root" + def user() = AccountService.getAccountByUserName(root).getOrElse(sys.error(s"user $root does not exists")) - val newAddress = "new mail address" - AccountService.updateAccount(user().copy(mailAddress = newAddress)) - assert(user().mailAddress == newAddress) + val newAddress = "new mail address" + AccountService.updateAccount(user().copy(mailAddress = newAddress)) + assert(user().mailAddress == newAddress) - val newUrl = Some("http://new.url.example/path") - AccountService.updateAccount(user().copy(url = newUrl)) - assert(user().url == newUrl) + val newUrl = Some("http://new.url.example/path") + AccountService.updateAccount(user().copy(url = newUrl)) + assert(user().url == newUrl) - val newDescription = Some("http://new.url.example/path") - AccountService.updateAccount(user().copy(description = newDescription)) - assert(user().description == newDescription) - }} + val newDescription = Some("http://new.url.example/path") + AccountService.updateAccount(user().copy(description = newDescription)) + assert(user().description == newDescription) + } + } - test("group") { withTestDB { implicit session => - val group1 = "group1" - val user1 = "root" - AccountService.createGroup(group1, None, None) + test("group") { + withTestDB { implicit session => + val group1 = "group1" + val user1 = "root" + AccountService.createGroup(group1, None, None) - assert(AccountService.getGroupMembers(group1) == Nil) - assert(AccountService.getGroupsByUserName(user1) == Nil) + assert(AccountService.getGroupMembers(group1) == Nil) + assert(AccountService.getGroupsByUserName(user1) == Nil) - AccountService.updateGroupMembers(group1, List((user1, true))) + AccountService.updateGroupMembers(group1, List((user1, true))) - assert(AccountService.getGroupMembers(group1) == List(GroupMember(group1, user1, true))) - assert(AccountService.getGroupsByUserName(user1) == List(group1)) + assert(AccountService.getGroupMembers(group1) == List(GroupMember(group1, user1, true))) + assert(AccountService.getGroupsByUserName(user1) == List(group1)) - AccountService.updateGroupMembers(group1, Nil) + AccountService.updateGroupMembers(group1, Nil) - assert(AccountService.getGroupMembers(group1) == Nil) - assert(AccountService.getGroupsByUserName(user1) == Nil) - }} + assert(AccountService.getGroupMembers(group1) == Nil) + assert(AccountService.getGroupsByUserName(user1) == Nil) + } + } - test("createGroup save description") { withTestDB { implicit session => - AccountService.createGroup("some-group", Some("some clever description"), None) - val maybeGroup = AccountService.getAccountByUserName("some-group") + test("createGroup save description") { + withTestDB { implicit session => + AccountService.createGroup("some-group", Some("some clever description"), None) + val maybeGroup = AccountService.getAccountByUserName("some-group") - assert(maybeGroup.flatMap(_.description) == Some("some clever description")) - }} + assert(maybeGroup.flatMap(_.description) == Some("some clever description")) + } + } - test("updateGroup save description") { withTestDB { implicit session => - AccountService.createGroup("a-group", None, None) + test("updateGroup save description") { + withTestDB { implicit session => + AccountService.createGroup("a-group", None, None) - AccountService.updateGroup("a-group", Some("new description"), None, false) + AccountService.updateGroup("a-group", Some("new description"), None, false) - val group = AccountService.getAccountByUserName("a-group") - assert(group.flatMap(_.description) == Some("new description")) - }} + val group = AccountService.getAccountByUserName("a-group") + assert(group.flatMap(_.description) == Some("new description")) + } + } } diff --git a/src/test/scala/gitbucket/core/service/CommitStatusServiceSpec.scala b/src/test/scala/gitbucket/core/service/CommitStatusServiceSpec.scala index bc38698..2d05044 100644 --- a/src/test/scala/gitbucket/core/service/CommitStatusServiceSpec.scala +++ b/src/test/scala/gitbucket/core/service/CommitStatusServiceSpec.scala @@ -6,70 +6,96 @@ import gitbucket.core.model.Profile.profile.blockingApi._ import org.scalatest.FunSuite - -class CommitStatusServiceSpec extends FunSuite with ServiceSpecBase with CommitStatusService - with RepositoryService with AccountService{ +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, + 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 = 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))) - }} + 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 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))) - }} + 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)) + ) + } + } } diff --git a/src/test/scala/gitbucket/core/service/IssuesServiceSpec.scala b/src/test/scala/gitbucket/core/service/IssuesServiceSpec.scala index 0238fee..9daa751 100644 --- a/src/test/scala/gitbucket/core/service/IssuesServiceSpec.scala +++ b/src/test/scala/gitbucket/core/service/IssuesServiceSpec.scala @@ -4,44 +4,94 @@ import gitbucket.core.service.IssuesService._ import org.scalatest.FunSuite - class IssuesServiceSpec extends FunSuite with ServiceSpecBase { test("getCommitStatues") { withTestDB { implicit session => - val user1 = generateNewUserWithDBRepository("user1","repo1") + val user1 = generateNewUserWithDBRepository("user1", "repo1") - def getCommitStatues(issueId: Int) = dummyService.getCommitStatues("user1","repo1",issueId) + def getCommitStatues(issueId: Int) = dummyService.getCommitStatues("user1", "repo1", issueId) assert(getCommitStatues(1) == None) val now = new java.util.Date() - val issueId = generateNewIssue("user1","repo1") + val issueId = generateNewIssue("user1", "repo1") assert(issueId == 1) assert(getCommitStatues(1) == None) - 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 + ) assert(getCommitStatues(1) == None) - val (is2, pr2) = generateNewPullRequest("user1/repo1/master","user1/repo1/feature1") + val (is2, pr2) = generateNewPullRequest("user1/repo1/master", "user1/repo1/feature1") assert(pr2.issueId == 2) // if there are no statuses, state is none assert(getCommitStatues(2) == None) // 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(2) == Some(CommitStatusInfo(1,1,Some("default"),Some(CommitState.SUCCESS),Some("http://exmple.com/ci"),Some("exampleService")))) + val cs2 = dummyService.createCommitStatus( + "user1", + "repo1", + "feature1", + "default", + CommitState.SUCCESS, + Some("http://exmple.com/ci"), + Some("exampleService"), + now, + user1 + ) + assert( + getCommitStatues(2) == Some( + 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) - assert(getCommitStatues(2) == Some(CommitStatusInfo(2,1,None,None,None,None))) + val cs3 = dummyService.createCommitStatus( + "user1", + "repo1", + "feature1", + "pend", + CommitState.PENDING, + Some("http://exmple.com/ci"), + Some("exampleService"), + now, + user1 + ) + assert(getCommitStatues(2) == Some(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(2) == Some(CommitStatusInfo(2,1,None,None,None,None))) + 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(2) == Some(CommitStatusInfo(2, 1, None, None, None, None))) } } -} \ No newline at end of file +} diff --git a/src/test/scala/gitbucket/core/service/LabelsServiceSpec.scala b/src/test/scala/gitbucket/core/service/LabelsServiceSpec.scala index 0141c5a..931e308 100644 --- a/src/test/scala/gitbucket/core/service/LabelsServiceSpec.scala +++ b/src/test/scala/gitbucket/core/service/LabelsServiceSpec.scala @@ -5,111 +5,129 @@ class LabelsServiceSpec extends FunSpec with ServiceSpecBase { describe("getLabels") { - it("should be empty when not have any labels") { withTestDB { implicit session => - generateNewUserWithDBRepository("user1", "repo1") + 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("user1", "repo2") + dummyService.createLabel("user1", "repo2", "label1", "000000") - generateNewUserWithDBRepository("user2", "repo1") - dummyService.createLabel("user2", "repo1", "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") + 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("user1", "repo2") + dummyService.createLabel("user1", "repo2", "label1", "000000") - generateNewUserWithDBRepository("user2", "repo1") - dummyService.createLabel("user2", "repo1", "label1", "000000") + generateNewUserWithDBRepository("user2", "repo1") + dummyService.createLabel("user2", "repo1", "label1", "000000") - def getLabels = dummyService.getLabels("user1", "repo1") + 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")) - ) - }} + 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") + 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") + 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("user1", "repo2") + dummyService.createLabel("user1", "repo2", "label1", "000000") - generateNewUserWithDBRepository("user2", "repo1") - dummyService.createLabel("user2", "repo1", "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") + 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("user1", "repo2") + dummyService.createLabel("user1", "repo2", "label1", "000000") - generateNewUserWithDBRepository("user2", "repo1") - dummyService.createLabel("user2", "repo1", "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")) - }} + 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"))) - }} + 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"))) - }} + 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) - }} + 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) + } + } } } diff --git a/src/test/scala/gitbucket/core/service/MergeServiceSpec.scala b/src/test/scala/gitbucket/core/service/MergeServiceSpec.scala index 18d9e52..95d87a2 100644 --- a/src/test/scala/gitbucket/core/service/MergeServiceSpec.scala +++ b/src/test/scala/gitbucket/core/service/MergeServiceSpec.scala @@ -12,32 +12,32 @@ import java.io.File class MergeServiceSpec extends FunSpec { - val service = new MergeService{} + val service = new MergeService {} val branch = "master" val issueId = 10 - def initRepository(owner:String, name:String): File = { + def initRepository(owner: String, name: String): File = { val dir = createTestRepository(getRepositoryDir(owner, name)) - using(Git.open(dir)){ git => - createFile(git, "refs/heads/master", "test.txt", "hoge" ) + using(Git.open(dir)) { git => + createFile(git, "refs/heads/master", "test.txt", "hoge") git.branchCreate().setStartPoint(s"refs/heads/master").setName(s"refs/pull/${issueId}/head").call() } dir } - def createConfrict(git:Git) = { - createFile(git, s"refs/heads/${branch}", "test.txt", "hoge2" ) - createFile(git, s"refs/pull/${issueId}/head", "test.txt", "hoge4" ) + def createConfrict(git: Git) = { + createFile(git, s"refs/heads/${branch}", "test.txt", "hoge2") + createFile(git, s"refs/pull/${issueId}/head", "test.txt", "hoge4") } describe("checkConflict, checkConflictCache") { it("checkConflict false if not conflicted, and create cache") { - val repo1Dir = initRepository("user1","repo1") + val repo1Dir = initRepository("user1", "repo1") assert(service.checkConflictCache("user1", "repo1", branch, issueId) == None) val conflicted = service.checkConflict("user1", "repo1", branch, issueId) assert(service.checkConflictCache("user1", "repo1", branch, issueId) == Some(None)) assert(conflicted.isEmpty) } it("checkConflict true if not conflicted, and create cache") { - val repo2Dir = initRepository("user1","repo2") - using(Git.open(repo2Dir)){ git => + val repo2Dir = initRepository("user1", "repo2") + using(Git.open(repo2Dir)) { git => createConfrict(git) } assert(service.checkConflictCache("user1", "repo2", branch, issueId) == None) @@ -45,74 +45,74 @@ assert(conflicted.isDefined) assert(service.checkConflictCache("user1", "repo2", branch, issueId) match { case Some(Some(_: String)) => true - case _ => false + case _ => false }) } } describe("checkConflictCache") { it("merged cache invalid if origin branch moved") { - val repo3Dir = initRepository("user1","repo3") + val repo3Dir = initRepository("user1", "repo3") assert(service.checkConflict("user1", "repo3", branch, issueId).isEmpty) assert(service.checkConflictCache("user1", "repo3", branch, issueId) == Some(None)) - using(Git.open(repo3Dir)){ git => - createFile(git, s"refs/heads/${branch}", "test.txt", "hoge2" ) + using(Git.open(repo3Dir)) { git => + createFile(git, s"refs/heads/${branch}", "test.txt", "hoge2") } assert(service.checkConflictCache("user1", "repo3", branch, issueId) == None) } it("merged cache invalid if request branch moved") { - val repo4Dir = initRepository("user1","repo4") + val repo4Dir = initRepository("user1", "repo4") assert(service.checkConflict("user1", "repo4", branch, issueId).isEmpty) assert(service.checkConflictCache("user1", "repo4", branch, issueId) == Some(None)) - using(Git.open(repo4Dir)){ git => - createFile(git, s"refs/pull/${issueId}/head", "test.txt", "hoge4" ) + using(Git.open(repo4Dir)) { git => + createFile(git, s"refs/pull/${issueId}/head", "test.txt", "hoge4") } assert(service.checkConflictCache("user1", "repo4", branch, issueId) == None) } it("should merged cache invalid if origin branch moved") { - val repo5Dir = initRepository("user1","repo5") + val repo5Dir = initRepository("user1", "repo5") assert(service.checkConflict("user1", "repo5", branch, issueId).isEmpty) assert(service.checkConflictCache("user1", "repo5", branch, issueId) == Some(None)) - using(Git.open(repo5Dir)){ git => - createFile(git, s"refs/heads/${branch}", "test.txt", "hoge2" ) + using(Git.open(repo5Dir)) { git => + createFile(git, s"refs/heads/${branch}", "test.txt", "hoge2") } assert(service.checkConflictCache("user1", "repo5", branch, issueId) == None) } it("conflicted cache invalid if request branch moved") { - val repo6Dir = initRepository("user1","repo6") - using(Git.open(repo6Dir)){ git => + val repo6Dir = initRepository("user1", "repo6") + using(Git.open(repo6Dir)) { git => createConfrict(git) } assert(service.checkConflict("user1", "repo6", branch, issueId).isDefined) assert(service.checkConflictCache("user1", "repo6", branch, issueId) match { case Some(Some(_: String)) => true - case _ => false + case _ => false }) - using(Git.open(repo6Dir)){ git => - createFile(git, s"refs/pull/${issueId}/head", "test.txt", "hoge4" ) + using(Git.open(repo6Dir)) { git => + createFile(git, s"refs/pull/${issueId}/head", "test.txt", "hoge4") } assert(service.checkConflictCache("user1", "repo6", branch, issueId) == None) } it("conflicted cache invalid if origin branch moved") { - val repo7Dir = initRepository("user1","repo7") - using(Git.open(repo7Dir)){ git => + val repo7Dir = initRepository("user1", "repo7") + using(Git.open(repo7Dir)) { git => createConfrict(git) } assert(service.checkConflict("user1", "repo7", branch, issueId).isDefined) assert(service.checkConflictCache("user1", "repo7", branch, issueId) match { case Some(Some(_)) => true - case _ => false + case _ => false }) - using(Git.open(repo7Dir)){ git => - createFile(git, s"refs/heads/${branch}", "test.txt", "hoge4" ) + using(Git.open(repo7Dir)) { git => + createFile(git, s"refs/heads/${branch}", "test.txt", "hoge4") } assert(service.checkConflictCache("user1", "repo7", branch, issueId) == None) } } 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 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") assert(getFile(git, branch, "test.txt").content.get == "hoge") val requestBranchId = git.getRepository.resolve(s"refs/pull/${issueId}/head") @@ -123,7 +123,7 @@ assert(commit.getCommitterIdent() == committer) assert(commit.getAuthorIdent() == committer) assert(commit.getFullMessage() == "merged") - assert(commit.getParents.toSet == Set( requestBranchId, masterId )) + assert(commit.getParents.toSet == Set(requestBranchId, masterId)) assert(getFile(git, branch, "test.txt").content.get == "hoge2") } } diff --git a/src/test/scala/gitbucket/core/service/ProtectedBranchServiceSpec.scala b/src/test/scala/gitbucket/core/service/ProtectedBranchServiceSpec.scala index 8265950..57b4b89 100644 --- a/src/test/scala/gitbucket/core/service/ProtectedBranchServiceSpec.scala +++ b/src/test/scala/gitbucket/core/service/ProtectedBranchServiceSpec.scala @@ -7,7 +7,11 @@ import gitbucket.core.service.ProtectedBranchService.{ProtectedBranchReceiveHook, ProtectedBranchInfo} import org.scalatest.FunSpec -class ProtectedBranchServiceSpec extends FunSpec with ServiceSpecBase with ProtectedBranchService with CommitStatusService { +class ProtectedBranchServiceSpec + extends FunSpec + with ServiceSpecBase + with ProtectedBranchService + with CommitStatusService { val receiveHook = new ProtectedBranchReceiveHook() val now = new java.util.Date() @@ -24,9 +28,19 @@ 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)) + 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")) } @@ -54,11 +68,18 @@ 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) + 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")) + assert( + receiveHook.preReceive("user1", "repo1", rp, rc, "user1") == Some("Cannot force-push to a protected branch") + ) } } } @@ -67,11 +88,18 @@ 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) + 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")) + assert( + receiveHook.preReceive("user1", "repo1", rp, rc, "user2") == Some("Cannot force-push to a protected branch") + ) } } } @@ -80,17 +108,38 @@ 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 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")) + 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")) + 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")) + 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")) + 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) } @@ -100,22 +149,43 @@ 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) + 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")) + 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")) + 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")) + 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")) + 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) } @@ -139,7 +209,7 @@ generateNewAccount("user2") generateNewAccount("user3") - x.updateGroupMembers("grp1", List("user1"->true, "user2"->false)) + x.updateGroupMembers("grp1", List("user1" -> true, "user2" -> false)) assert(x.isAdministrator("user1") == true) assert(x.isAdministrator("user2") == false) assert(x.isAdministrator("user3") == false) @@ -181,8 +251,8 @@ 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) + assert(ProtectedBranchInfo("user1", "repo1", true, Seq("must"), true).needStatusCheck("user2") == true) + assert(ProtectedBranchInfo("user1", "repo1", true, Seq("must"), true).needStatusCheck("user1") == true) } } } diff --git a/src/test/scala/gitbucket/core/service/PullRequestServiceSpec.scala b/src/test/scala/gitbucket/core/service/PullRequestServiceSpec.scala index 08c442f..40ff25e 100644 --- a/src/test/scala/gitbucket/core/service/PullRequestServiceSpec.scala +++ b/src/test/scala/gitbucket/core/service/PullRequestServiceSpec.scala @@ -3,9 +3,17 @@ import gitbucket.core.model._ import org.scalatest.FunSpec -class PullRequestServiceSpec extends FunSpec with ServiceSpecBase - with PullRequestService with IssuesService with AccountService with RepositoryService with CommitsService - with LabelsService with MilestonesService with PrioritiesService { +class PullRequestServiceSpec + extends FunSpec + with ServiceSpecBase + with PullRequestService + with IssuesService + with AccountService + with RepositoryService + with CommitsService + with LabelsService + with MilestonesService + with PrioritiesService { def swap(r: (Issue, PullRequest)) = (r._2 -> r._1) @@ -13,23 +21,25 @@ 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 other branch and not closed. - |return None if all pull request is closed""".stripMargin.trim) { withTestDB { implicit se => - generateNewUserWithDBRepository("user1", "repo1") - generateNewUserWithDBRepository("user1", "repo2") - generateNewUserWithDBRepository("user2", "repo1") - generateNewPullRequest("user1/repo1/master", "user1/repo1/head2") // not target branch - generateNewPullRequest("user1/repo1/head1", "user1/repo1/master") // not target branch ( swap from, to ) - generateNewPullRequest("user1/repo1/master", "user2/repo1/head1") // other user - generateNewPullRequest("user1/repo1/master", "user1/repo2/head1") // other repository - 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")) - assert(getPullRequestFromBranch("user1", "repo1", "head1", "master") == Some(r2)) - updateClosed("user1", "repo1", r2._1.issueId, true) - 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) - assert(getPullRequestFromBranch("user1", "repo1", "head1", "master") == None) - } } + |return None if all pull request is closed""".stripMargin.trim) { + withTestDB { implicit se => + generateNewUserWithDBRepository("user1", "repo1") + generateNewUserWithDBRepository("user1", "repo2") + generateNewUserWithDBRepository("user2", "repo1") + generateNewPullRequest("user1/repo1/master", "user1/repo1/head2") // not target branch + generateNewPullRequest("user1/repo1/head1", "user1/repo1/master") // not target branch ( swap from, to ) + generateNewPullRequest("user1/repo1/master", "user2/repo1/head1") // other user + generateNewPullRequest("user1/repo1/master", "user1/repo2/head1") // other repository + 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")) + assert(getPullRequestFromBranch("user1", "repo1", "head1", "master") == Some(r2)) + updateClosed("user1", "repo1", r2._1.issueId, true) + 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) + assert(getPullRequestFromBranch("user1", "repo1", "head1", "master") == None) + } + } } } diff --git a/src/test/scala/gitbucket/core/service/RepositoryServiceSpec.scala b/src/test/scala/gitbucket/core/service/RepositoryServiceSpec.scala index 0b13b4b..84b02ff 100644 --- a/src/test/scala/gitbucket/core/service/RepositoryServiceSpec.scala +++ b/src/test/scala/gitbucket/core/service/RepositoryServiceSpec.scala @@ -3,31 +3,37 @@ import gitbucket.core.model._ import org.scalatest.FunSuite -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) +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")) + service.enableBranchProtection("root", "repo", "branch", true, Seq("must1", "must2")) - val orgPbi = service.getProtectedBranchInfo("root", "repo", "branch") - val org = service.getCommitStatus("root","repo", id).get + val orgPbi = service.getProtectedBranchInfo("root", "repo", "branch") + val org = service.getCommitStatus("root", "repo", id).get - renameRepository("root","repo","tester","repo2") + 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")) - }} + 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") + ) + } + } } diff --git a/src/test/scala/gitbucket/core/service/ServiceSpecBase.scala b/src/test/scala/gitbucket/core/service/ServiceSpecBase.scala index a2a2847..f7ff3be 100644 --- a/src/test/scala/gitbucket/core/service/ServiceSpecBase.scala +++ b/src/test/scala/gitbucket/core/service/ServiceSpecBase.scala @@ -18,14 +18,13 @@ import scala.util.Random - trait ServiceSpecBase { def withTestDB[A](action: (Session) => A): A = { - FileUtil.withTmpDir(new File(FileUtils.getTempDirectory(), Random.alphanumeric.take(10).mkString)){ dir => + FileUtil.withTmpDir(new File(FileUtils.getTempDirectory(), Random.alphanumeric.take(10).mkString)) { dir => val (url, user, pass) = (DatabaseConfig.url(Some(dir.toString)), DatabaseConfig.user, DatabaseConfig.password) org.h2.Driver.load() - using(DriverManager.getConnection(url, user, pass)){ conn => + using(DriverManager.getConnection(url, user, pass)) { conn => val solidbase = new Solidbase() val db = new H2Database() db.setConnection(new JdbcConnection(conn)) // TODO Remove setConnection in the future @@ -37,49 +36,55 @@ } } - def generateNewAccount(name:String)(implicit s:Session):Account = { + def generateNewAccount(name: String)(implicit s: Session): Account = { AccountService.createAccount(name, name, name, s"${name}@example.com", false, None, None) user(name) } - def user(name:String)(implicit s:Session):Account = AccountService.getAccountByUserName(name).get + def user(name: String)(implicit s: Session): Account = AccountService.getAccountByUserName(name).get lazy val dummyService = new RepositoryService with AccountService with IssuesService with PullRequestService - with CommitsService with CommitStatusService with LabelsService with MilestonesService with PrioritiesService (){} + with CommitsService with CommitStatusService with LabelsService with MilestonesService with PrioritiesService() {} - def generateNewUserWithDBRepository(userName:String, repositoryName:String)(implicit s:Session):Account = { + def generateNewUserWithDBRepository(userName: String, repositoryName: String)(implicit s: Session): Account = { val ac = AccountService.getAccountByUserName(userName).getOrElse(generateNewAccount(userName)) dummyService.insertRepository(repositoryName, userName, None, false) ac } - def generateNewIssue(userName:String, repositoryName:String, loginUser:String="root")(implicit s:Session): Int = { + def generateNewIssue(userName: String, repositoryName: String, loginUser: String = "root")( + implicit s: Session + ): Int = { dummyService.insertIssue( - owner = userName, - repository = repositoryName, - loginUser = loginUser, - title = "issue title", - content = None, + owner = userName, + repository = repositoryName, + loginUser = loginUser, + title = "issue title", + content = None, assignedUserName = None, - milestoneId = None, - priorityId = None, - isPullRequest = true) + milestoneId = None, + priorityId = None, + isPullRequest = true + ) } - def generateNewPullRequest(base:String, request:String, loginUser:String=null)(implicit s:Session):(Issue, PullRequest) = { - val Array(baseUserName, baseRepositoryName, baesBranch)=base.split("/") - val Array(requestUserName, requestRepositoryName, requestBranch)=request.split("/") + def generateNewPullRequest(base: String, request: String, loginUser: String = null)( + implicit s: Session + ): (Issue, PullRequest) = { + val Array(baseUserName, baseRepositoryName, baesBranch) = base.split("/") + val Array(requestUserName, requestRepositoryName, requestBranch) = request.split("/") val issueId = generateNewIssue(baseUserName, baseRepositoryName, Option(loginUser).getOrElse(requestUserName)) dummyService.createPullRequest( - originUserName = baseUserName, - originRepositoryName = baseRepositoryName, - issueId = issueId, - originBranch = baesBranch, - requestUserName = requestUserName, + originUserName = baseUserName, + originRepositoryName = baseRepositoryName, + issueId = issueId, + originBranch = baesBranch, + requestUserName = requestUserName, requestRepositoryName = requestRepositoryName, - requestBranch = requestBranch, - commitIdFrom = baesBranch, - commitIdTo = requestBranch) + requestBranch = requestBranch, + commitIdFrom = baesBranch, + commitIdTo = requestBranch + ) dummyService.getPullRequest(baseUserName, baseRepositoryName, issueId).get } } diff --git a/src/test/scala/gitbucket/core/service/WebHookServiceSpec.scala b/src/test/scala/gitbucket/core/service/WebHookServiceSpec.scala index 32fdb65..9f14a24 100644 --- a/src/test/scala/gitbucket/core/service/WebHookServiceSpec.scala +++ b/src/test/scala/gitbucket/core/service/WebHookServiceSpec.scala @@ -4,77 +4,129 @@ import org.scalatest.FunSuite import gitbucket.core.model.WebHookContentType - class WebHookServiceSpec extends FunSuite with ServiceSpecBase { lazy val service = new WebHookPullRequestService with AccountService with RepositoryService with PullRequestService - with IssuesService with CommitsService with LabelsService with MilestonesService with PrioritiesService + with IssuesService with CommitsService with LabelsService with MilestonesService with PrioritiesService - 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")) + 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")) - assert(service.getPullRequestsByRequestForWebhook("user1","repo1","master1") == Map.empty) + assert(service.getPullRequestsByRequestForWebhook("user1", "repo1", "master1") == Map.empty) - val r = service.getPullRequestsByRequestForWebhook("user2","repo2","master2").mapValues(_.map(_.url).toSet) + val r = service.getPullRequestsByRequestForWebhook("user2", "repo2", "master2").mapValues(_.map(_.url).toSet) - 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")) + 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) - 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")) - } } + 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((RepositoryWebHook("user1","repo1","http://example.com", formType, Some("key")),Set(WebHook.PullRequest)))) - assert(service.getWebHook("user1", "repo1", "http://example.com") == Some((RepositoryWebHook("user1","repo1","http://example.com", formType, Some("key")),Set(WebHook.PullRequest)))) - assert(service.getWebHooksByEvent("user1", "repo1", WebHook.PullRequest) == List((RepositoryWebHook("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((RepositoryWebHook("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((RepositoryWebHook("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("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( + (RepositoryWebHook("user1", "repo1", "http://example.com", formType, Some("key")), Set(WebHook.PullRequest)) + ) + ) + assert( + service.getWebHook("user1", "repo1", "http://example.com") == Some( + (RepositoryWebHook("user1", "repo1", "http://example.com", formType, Some("key")), Set(WebHook.PullRequest)) + ) + ) + assert( + service.getWebHooksByEvent("user1", "repo1", WebHook.PullRequest) == List( + (RepositoryWebHook("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( + ( + RepositoryWebHook("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( + (RepositoryWebHook("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( - RepositoryWebHook("user1","repo1","http://example.com/1", ctype, Some("key"))->Set(WebHook.PullRequest), - RepositoryWebHook("user1","repo1","http://example.com/2", ctype, Some("key"))->Set(WebHook.Push), - RepositoryWebHook("user1","repo1","http://example.com/3", ctype, Some("key"))->Set(WebHook.PullRequest,WebHook.Push))) - assert(service.getWebHooksByEvent("user1", "repo1", WebHook.PullRequest) == List( - RepositoryWebHook("user1","repo1","http://example.com/1", ctype, Some("key")), - RepositoryWebHook("user1","repo1","http://example.com/3", ctype, Some("key")))) - } } + 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( + RepositoryWebHook("user1", "repo1", "http://example.com/1", ctype, Some("key")) -> Set(WebHook.PullRequest), + RepositoryWebHook("user1", "repo1", "http://example.com/2", ctype, Some("key")) -> Set(WebHook.Push), + RepositoryWebHook("user1", "repo1", "http://example.com/3", ctype, Some("key")) -> Set( + WebHook.PullRequest, + WebHook.Push + ) + ) + ) + assert( + service.getWebHooksByEvent("user1", "repo1", WebHook.PullRequest) == List( + RepositoryWebHook("user1", "repo1", "http://example.com/1", ctype, Some("key")), + RepositoryWebHook("user1", "repo1", "http://example.com/3", ctype, Some("key")) + ) + ) + } + } } diff --git a/src/test/scala/gitbucket/core/ssh/GitCommandSpec.scala b/src/test/scala/gitbucket/core/ssh/GitCommandSpec.scala index a3afc82..9051c57 100644 --- a/src/test/scala/gitbucket/core/ssh/GitCommandSpec.scala +++ b/src/test/scala/gitbucket/core/ssh/GitCommandSpec.scala @@ -8,22 +8,24 @@ val factory = new GitCommandFactory("http://localhost:8080", None) describe("createCommand") { - it("should return GitReceivePack when command is git-receive-pack"){ + it("should return GitReceivePack when command is git-receive-pack") { assert(factory.createCommand("git-receive-pack '/owner/repo.git'").isInstanceOf[DefaultGitReceivePack] == true) - assert(factory.createCommand("git-receive-pack '/owner/repo.wiki.git'").isInstanceOf[DefaultGitReceivePack] == true) + assert( + factory.createCommand("git-receive-pack '/owner/repo.wiki.git'").isInstanceOf[DefaultGitReceivePack] == true + ) } - it("should return GitUploadPack when command is git-upload-pack"){ + it("should return GitUploadPack when command is git-upload-pack") { assert(factory.createCommand("git-upload-pack '/owner/repo.git'").isInstanceOf[DefaultGitUploadPack] == true) assert(factory.createCommand("git-upload-pack '/owner/repo.wiki.git'").isInstanceOf[DefaultGitUploadPack] == true) } - it("should return UnknownCommand when command is not git-(upload|receive)-pack"){ + it("should return UnknownCommand when command is not git-(upload|receive)-pack") { assert(factory.createCommand("git- '/owner/repo.git'").isInstanceOf[UnknownCommand] == true) assert(factory.createCommand("git-pack '/owner/repo.git'").isInstanceOf[UnknownCommand] == true) assert(factory.createCommand("git-a-pack '/owner/repo.git'").isInstanceOf[UnknownCommand] == true) assert(factory.createCommand("git-up-pack '/owner/repo.git'").isInstanceOf[UnknownCommand] == true) assert(factory.createCommand("\ngit-upload-pack '/owner/repo.git'").isInstanceOf[UnknownCommand] == true) } - it("should return UnknownCommand when git command has no valid arguments"){ + it("should return UnknownCommand when git command has no valid arguments") { // must be: git-upload-pack '/owner/repository_name.git' assert(factory.createCommand("git-upload-pack").isInstanceOf[UnknownCommand] == true) assert(factory.createCommand("git-upload-pack /owner/repo.git").isInstanceOf[UnknownCommand] == true) diff --git a/src/test/scala/gitbucket/core/util/DirectorySpec.scala b/src/test/scala/gitbucket/core/util/DirectorySpec.scala index bc22327..2e5f0da 100644 --- a/src/test/scala/gitbucket/core/util/DirectorySpec.scala +++ b/src/test/scala/gitbucket/core/util/DirectorySpec.scala @@ -4,8 +4,8 @@ class DirectorySpec extends FunSpec { - describe("GitBucketHome"){ - it("should set under target in test scope"){ + describe("GitBucketHome") { + it("should set under target in test scope") { assert(Directory.GitBucketHome == new java.io.File("target/gitbucket_home_for_test").getAbsolutePath) } } diff --git a/src/test/scala/gitbucket/core/util/GitSpecUtil.scala b/src/test/scala/gitbucket/core/util/GitSpecUtil.scala index 15fbf55..976778d 100644 --- a/src/test/scala/gitbucket/core/util/GitSpecUtil.scala +++ b/src/test/scala/gitbucket/core/util/GitSpecUtil.scala @@ -17,7 +17,7 @@ object GitSpecUtil { def withTestFolder[U](f: File => U): U = { val folder = new File(System.getProperty("java.io.tmpdir"), "test-" + System.nanoTime) - if(!folder.mkdirs()){ + if (!folder.mkdirs()) { throw new java.io.IOException("can't create folder " + folder.getAbsolutePath) } try { @@ -34,24 +34,43 @@ JGitUtil.initRepository(dir) dir } - def createFile(git: Git, branch: String, name: String, content: String, - autorName: String = "dummy", autorEmail: String = "dummy@example.com", - message: String = "test commit") { + def createFile( + git: Git, + branch: String, + name: String, + content: String, + autorName: String = "dummy", + autorEmail: String = "dummy@example.com", + message: String = "test commit" + ) { val builder = DirCache.newInCore.builder() val inserter = git.getRepository.newObjectInserter() val headId = git.getRepository.resolve(branch + "^{commit}") - if(headId!=null){ - JGitUtil.processTree(git, headId){ (path, tree) => - if(name != path){ + if (headId != null) { + JGitUtil.processTree(git, headId) { (path, tree) => + if (name != path) { builder.add(JGitUtil.createDirCacheEntry(path, tree.getEntryFileMode, tree.getEntryObjectId)) } } } - builder.add(JGitUtil.createDirCacheEntry(name, FileMode.REGULAR_FILE, - inserter.insert(Constants.OBJ_BLOB, content.getBytes("UTF-8")))) + builder.add( + JGitUtil.createDirCacheEntry( + name, + FileMode.REGULAR_FILE, + inserter.insert(Constants.OBJ_BLOB, content.getBytes("UTF-8")) + ) + ) builder.finish() - JGitUtil.createNewCommit(git, inserter, headId, builder.getDirCache.writeTree(inserter), - branch, autorName, autorEmail, message) + JGitUtil.createNewCommit( + git, + inserter, + headId, + builder.getDirCache.writeTree(inserter), + branch, + autorName, + autorEmail, + message + ) inserter.flush() inserter.close() } @@ -70,7 +89,7 @@ } JGitUtil.getContentInfo(git, path, objectId) } - def mergeAndCommit(git: Git, into:String, branch:String, message:String = null):Unit = { + def mergeAndCommit(git: Git, into: String, branch: String, message: String = null): Unit = { val repository = git.getRepository val merger = MergeStrategy.RECURSIVE.newMerger(repository, true) val mergeBaseTip = repository.resolve(into) @@ -80,10 +99,10 @@ } catch { case e: NoMergeBaseException => true } - if(conflicted){ + if (conflicted) { throw new RuntimeException("conflict!") } - val mergeTipCommit = using(new RevWalk( repository ))(_.parseCommit( mergeTip )) + val mergeTipCommit = using(new RevWalk(repository))(_.parseCommit(mergeTip)) val committer = mergeTipCommit.getCommitterIdent // creates merge commit val mergeCommit = new CommitBuilder() diff --git a/src/test/scala/gitbucket/core/util/JGitUtilSpec.scala b/src/test/scala/gitbucket/core/util/JGitUtilSpec.scala index b6fd277..e85f00d 100644 --- a/src/test/scala/gitbucket/core/util/JGitUtilSpec.scala +++ b/src/test/scala/gitbucket/core/util/JGitUtilSpec.scala @@ -5,7 +5,7 @@ class JGitUtilSpec extends FunSuite { - test("getFileList(git: Git, revision: String, path)"){ + test("getFileList(git: Git, revision: String, path)") { withTestRepository { git => def list(branch: String, path: String) = JGitUtil.getFileList(git, branch, path).map(finfo => (finfo.name, finfo.message, finfo.isDirectory)) @@ -44,49 +44,118 @@ createFile(git, "master", "README5.md", "body5", message = "commit5") - assert(list("master", ".") == List(("dir/subdir", "commit4", true), ("README.md", "commit2", false), ("README5.md", "commit5", false))) + assert( + list("master", ".") == List( + ("dir/subdir", "commit4", true), + ("README.md", "commit2", false), + ("README5.md", "commit5", false) + ) + ) assert(list("master", "dir/subdir") == List(("File3.md", "commit3", false), ("File4.md", "commit4", false))) assert(list("branch", ".") == Nil) assert(list("branch", "dir/subdir") == Nil) createFile(git, "master", "README.md", "body6", message = "commit6") - assert(list("master", ".") == List(("dir/subdir", "commit4", true), ("README.md", "commit6", false), ("README5.md", "commit5", false))) + assert( + list("master", ".") == List( + ("dir/subdir", "commit4", true), + ("README.md", "commit6", false), + ("README5.md", "commit5", false) + ) + ) assert(list("master", "dir/subdir") == List(("File3.md", "commit3", false), ("File4.md", "commit4", false))) assert(list("branch", ".") == Nil) assert(list("branch", "dir/subdir") == Nil) git.branchCreate().setName("branch").setStartPoint("master").call() - assert(list("master", ".") == List(("dir/subdir", "commit4", true), ("README.md", "commit6", false), ("README5.md", "commit5", false))) + assert( + list("master", ".") == List( + ("dir/subdir", "commit4", true), + ("README.md", "commit6", false), + ("README5.md", "commit5", false) + ) + ) assert(list("master", "dir/subdir") == List(("File3.md", "commit3", false), ("File4.md", "commit4", false))) - assert(list("branch", ".") == List(("dir/subdir", "commit4", true), ("README.md", "commit6", false), ("README5.md", "commit5", false))) + assert( + list("branch", ".") == List( + ("dir/subdir", "commit4", true), + ("README.md", "commit6", false), + ("README5.md", "commit5", false) + ) + ) assert(list("branch", "dir/subdir") == List(("File3.md", "commit3", false), ("File4.md", "commit4", false))) createFile(git, "branch", "dir/subdir/File3.md", "body7", message = "commit7") - assert(list("master", ".") == List(("dir/subdir", "commit4", true), ("README.md", "commit6", false), ("README5.md", "commit5", false))) + assert( + list("master", ".") == List( + ("dir/subdir", "commit4", true), + ("README.md", "commit6", false), + ("README5.md", "commit5", false) + ) + ) assert(list("master", "dir/subdir") == List(("File3.md", "commit3", false), ("File4.md", "commit4", false))) - assert(list("branch", ".") == List(("dir/subdir", "commit7", true), ("README.md", "commit6", false), ("README5.md", "commit5", false))) + assert( + list("branch", ".") == List( + ("dir/subdir", "commit7", true), + ("README.md", "commit6", false), + ("README5.md", "commit5", false) + ) + ) assert(list("branch", "dir/subdir") == List(("File3.md", "commit7", false), ("File4.md", "commit4", false))) createFile(git, "master", "dir8/File8.md", "body8", message = "commit8") - assert(list("master", ".") == List(("dir/subdir", "commit4", true), ("dir8", "commit8", true), ("README.md", "commit6", false), ("README5.md", "commit5", false))) + assert( + list("master", ".") == List( + ("dir/subdir", "commit4", true), + ("dir8", "commit8", true), + ("README.md", "commit6", false), + ("README5.md", "commit5", false) + ) + ) assert(list("master", "dir/subdir") == List(("File3.md", "commit3", false), ("File4.md", "commit4", false))) - assert(list("branch", ".") == List(("dir/subdir", "commit7", true), ("README.md", "commit6", false), ("README5.md", "commit5", false))) + assert( + list("branch", ".") == List( + ("dir/subdir", "commit7", true), + ("README.md", "commit6", false), + ("README5.md", "commit5", false) + ) + ) assert(list("branch", "dir/subdir") == List(("File3.md", "commit7", false), ("File4.md", "commit4", false))) createFile(git, "branch", "dir/subdir9/File9.md", "body9", message = "commit9") - assert(list("master", ".") == List(("dir/subdir", "commit4", true), ("dir8", "commit8", true), ("README.md", "commit6", false), ("README5.md", "commit5", false))) + assert( + list("master", ".") == List( + ("dir/subdir", "commit4", true), + ("dir8", "commit8", true), + ("README.md", "commit6", false), + ("README5.md", "commit5", false) + ) + ) assert(list("master", "dir/subdir") == List(("File3.md", "commit3", false), ("File4.md", "commit4", false))) - assert(list("branch", ".") == List(("dir", "commit9", true), ("README.md", "commit6", false), ("README5.md", "commit5", false))) + assert( + list("branch", ".") == List( + ("dir", "commit9", true), + ("README.md", "commit6", false), + ("README5.md", "commit5", false) + ) + ) assert(list("branch", "dir/subdir") == List(("File3.md", "commit7", false), ("File4.md", "commit4", false))) mergeAndCommit(git, "master", "branch", message = "merge10") - assert(list("master", ".") == List(("dir", "commit9", true), ("dir8", "commit8", true), ("README.md", "commit6", false), ("README5.md", "commit5", false))) + assert( + list("master", ".") == List( + ("dir", "commit9", true), + ("dir8", "commit8", true), + ("README.md", "commit6", false), + ("README5.md", "commit5", false) + ) + ) assert(list("master", "dir/subdir") == List(("File3.md", "commit7", false), ("File4.md", "commit4", false))) } } diff --git a/src/test/scala/gitbucket/core/util/StringUtilSpec.scala b/src/test/scala/gitbucket/core/util/StringUtilSpec.scala index ecb1e56..f2721bc 100644 --- a/src/test/scala/gitbucket/core/util/StringUtilSpec.scala +++ b/src/test/scala/gitbucket/core/util/StringUtilSpec.scala @@ -30,7 +30,9 @@ describe("escapeHtml") { it("should escape &, <, > and \"") { - assert(StringUtil.escapeHtml("a & b") == "<a href="/test">a & b</a>") + assert( + StringUtil.escapeHtml("a & b") == "<a href="/test">a & b</a>" + ) } } @@ -66,21 +68,45 @@ describe("getRepositoryViewerUrl") { val baseUrl = Some("http://localhost:8080") - it("should convert GitBucket repository url"){ - assert(StringUtil.getRepositoryViewerUrl("http://localhost:8080/git/root/gitbucket.git", baseUrl) == "http://localhost:8080/root/gitbucket") - assert(StringUtil.getRepositoryViewerUrl("http://root@localhost:8080/git/root/gitbucket.git", baseUrl) == "http://localhost:8080/root/gitbucket") + it("should convert GitBucket repository url") { + assert( + StringUtil + .getRepositoryViewerUrl("http://localhost:8080/git/root/gitbucket.git", baseUrl) == "http://localhost:8080/root/gitbucket" + ) + assert( + StringUtil + .getRepositoryViewerUrl("http://root@localhost:8080/git/root/gitbucket.git", baseUrl) == "http://localhost:8080/root/gitbucket" + ) } - it("should convert GitHub repository url"){ - assert(StringUtil.getRepositoryViewerUrl("https://github.com/root/gitbucket.git", baseUrl) == "https://github.com/root/gitbucket") - assert(StringUtil.getRepositoryViewerUrl("https://root@github.com/root/gitbucket.git", baseUrl) == "https://github.com/root/gitbucket") + it("should convert GitHub repository url") { + assert( + StringUtil + .getRepositoryViewerUrl("https://github.com/root/gitbucket.git", baseUrl) == "https://github.com/root/gitbucket" + ) + assert( + StringUtil + .getRepositoryViewerUrl("https://root@github.com/root/gitbucket.git", baseUrl) == "https://github.com/root/gitbucket" + ) } - it("should convert BitBucket repository url"){ - assert(StringUtil.getRepositoryViewerUrl("https://bitbucket.org/root/gitbucket.git", baseUrl) == "https://bitbucket.org/root/gitbucket") - assert(StringUtil.getRepositoryViewerUrl("https://root@bitbucket.org/root/gitbucket.git", baseUrl) == "https://bitbucket.org/root/gitbucket") + it("should convert BitBucket repository url") { + assert( + StringUtil + .getRepositoryViewerUrl("https://bitbucket.org/root/gitbucket.git", baseUrl) == "https://bitbucket.org/root/gitbucket" + ) + assert( + StringUtil + .getRepositoryViewerUrl("https://root@bitbucket.org/root/gitbucket.git", baseUrl) == "https://bitbucket.org/root/gitbucket" + ) } - it("should convert GitLab repository url"){ - assert(StringUtil.getRepositoryViewerUrl("https://gitlab.com/root/gitbucket.git", baseUrl) == "https://gitlab.com/root/gitbucket") - assert(StringUtil.getRepositoryViewerUrl("https://root@gitlab.com/root/gitbucket.git", baseUrl) == "https://gitlab.com/root/gitbucket") + it("should convert GitLab repository url") { + assert( + StringUtil + .getRepositoryViewerUrl("https://gitlab.com/root/gitbucket.git", baseUrl) == "https://gitlab.com/root/gitbucket" + ) + assert( + StringUtil + .getRepositoryViewerUrl("https://root@gitlab.com/root/gitbucket.git", baseUrl) == "https://gitlab.com/root/gitbucket" + ) } } } diff --git a/src/test/scala/gitbucket/core/view/AvatarImageProviderSpec.scala b/src/test/scala/gitbucket/core/view/AvatarImageProviderSpec.scala index 2e08135..6baf939 100644 --- a/src/test/scala/gitbucket/core/view/AvatarImageProviderSpec.scala +++ b/src/test/scala/gitbucket/core/view/AvatarImageProviderSpec.scala @@ -13,7 +13,6 @@ import org.scalatest.mockito.MockitoSugar import play.twirl.api.Html - class AvatarImageProviderSpec extends FunSpec with MockitoSugar { val request = mock[HttpServletRequest] @@ -28,8 +27,10 @@ implicit val context = Context(createSystemSettings(true), None, request) val provider = new AvatarImageProviderImpl(Some(createAccount(None))) - assert(provider.toHtml("user", 32).toString == - "") + assert( + provider.toHtml("user", 32).toString == + "" + ) } it("should show uploaded image even if gravatar integration is enabled") { @@ -38,8 +39,10 @@ val date = new SimpleDateFormat("yyyyMMddHHmmss").format(account.updatedDate) val provider = new AvatarImageProviderImpl(Some(account)) - assert(provider.toHtml("user", 32).toString == - s"""""") + assert( + provider.toHtml("user", 32).toString == + s"""""" + ) } it("should show local image for no image account if gravatar integration is disabled") { @@ -48,79 +51,90 @@ val date = new SimpleDateFormat("yyyyMMddHHmmss").format(account.updatedDate) val provider = new AvatarImageProviderImpl(Some(account)) - assert(provider.toHtml("user", 32).toString == - s"""""") + assert( + provider.toHtml("user", 32).toString == + s"""""" + ) } it("should show Gravatar image for specified mail address if gravatar integration is enabled") { implicit val context = Context(createSystemSettings(true), None, request) val provider = new AvatarImageProviderImpl(None) - assert(provider.toHtml("user", 20, "hoge@hoge.com").toString == - "") + assert( + provider.toHtml("user", 20, "hoge@hoge.com").toString == + "" + ) } it("should show unknown image for unknown user if gravatar integration is enabled") { implicit val context = Context(createSystemSettings(true), None, request) val provider = new AvatarImageProviderImpl(None) - assert(provider.toHtml("user", 20).toString == - "") + assert( + provider.toHtml("user", 20).toString == + "" + ) } it("should show unknown image for specified mail address if gravatar integration is disabled") { implicit val context = Context(createSystemSettings(false), None, request) val provider = new AvatarImageProviderImpl(None) - assert(provider.toHtml("user", 20, "hoge@hoge.com").toString == - "") + assert( + provider.toHtml("user", 20, "hoge@hoge.com").toString == + "" + ) } it("should add tooltip if it's enabled") { implicit val context = Context(createSystemSettings(false), None, request) val provider = new AvatarImageProviderImpl(None) - assert(provider.toHtml("user", 20, "hoge@hoge.com", true).toString == - "") + assert( + provider.toHtml("user", 20, "hoge@hoge.com", true).toString == + "" + ) } } private def createAccount(image: Option[String]) = Account( - userName = "user", - fullName = "user@localhost", - mailAddress = "", - password = "", - isAdmin = false, - url = None, + userName = "user", + fullName = "user@localhost", + mailAddress = "", + password = "", + isAdmin = false, + url = None, registeredDate = new Date(), - updatedDate = new Date(), - lastLoginDate = None, - image = image, + updatedDate = new Date(), + lastLoginDate = None, + image = image, isGroupAccount = false, - isRemoved = false, - description = None) + isRemoved = false, + description = None + ) private def createSystemSettings(useGravatar: Boolean) = SystemSettings( - baseUrl = None, - information = None, + baseUrl = None, + information = None, allowAccountRegistration = false, - allowAnonymousAccess = true, + allowAnonymousAccess = true, isCreateRepoOptionPublic = true, - gravatar = useGravatar, - notification = false, - activityLogLimit = None, - ssh = false, - sshHost = None, - sshPort = None, - useSMTP = false, - smtp = None, - ldapAuthentication = false, - ldap = None, - oidcAuthentication = false, - oidc = None, - skinName = "skin-blue" + gravatar = useGravatar, + notification = false, + activityLogLimit = None, + ssh = false, + sshHost = None, + sshPort = None, + useSMTP = false, + smtp = None, + ldapAuthentication = false, + ldap = None, + oidcAuthentication = false, + oidc = None, + skinName = "skin-blue" ) /** @@ -128,8 +142,9 @@ */ class AvatarImageProviderImpl(account: Option[Account]) extends AvatarImageProvider with RequestCache { - def toHtml(userName: String, size: Int, mailAddress: String = "", tooltip: Boolean = false) - (implicit context: Context): Html = getAvatarImageHtml(userName, size, mailAddress, tooltip) + def toHtml(userName: String, size: Int, mailAddress: String = "", tooltip: Boolean = false)( + implicit context: Context + ): Html = getAvatarImageHtml(userName, size, mailAddress, tooltip) override def getAccountByMailAddress(mailAddress: String)(implicit context: Context): Option[Account] = account override def getAccountByUserName(userName: String)(implicit context: Context): Option[Account] = account diff --git a/src/test/scala/gitbucket/core/view/HelpersSpec.scala b/src/test/scala/gitbucket/core/view/HelpersSpec.scala index 22a79aa..fc1a2b2 100644 --- a/src/test/scala/gitbucket/core/view/HelpersSpec.scala +++ b/src/test/scala/gitbucket/core/view/HelpersSpec.scala @@ -35,7 +35,9 @@ it("should convert a multiple links within text") { val before = "Example Project. http://example.com. (See also https://github.com/)" val after = decorateHtml(urlLink(before), repository) - assert(after == """Example Project. http://example.com. (See also https://github.com/)""") + assert( + after == """Example Project. http://example.com. (See also https://github.com/)""" + ) } it("should properly escape html metacharacters") { diff --git a/src/test/scala/gitbucket/core/view/MarkdownSpec.scala b/src/test/scala/gitbucket/core/view/MarkdownSpec.scala index 54e437c..802cd18 100644 --- a/src/test/scala/gitbucket/core/view/MarkdownSpec.scala +++ b/src/test/scala/gitbucket/core/view/MarkdownSpec.scala @@ -90,4 +90,3 @@ } } } - diff --git a/src/test/scala/gitbucket/core/view/PaginationSpec.scala b/src/test/scala/gitbucket/core/view/PaginationSpec.scala index eb23efe..790368a 100644 --- a/src/test/scala/gitbucket/core/view/PaginationSpec.scala +++ b/src/test/scala/gitbucket/core/view/PaginationSpec.scala @@ -15,11 +15,11 @@ describe("omitLeft and omitRight") { it("should return true if pagination links at their side will be omitted") { - defining(Pagination(1, 100, 10, 6)){ pagination => + defining(Pagination(1, 100, 10, 6)) { pagination => assert(pagination.omitLeft == false) assert(pagination.omitRight == true) } - defining(Pagination(9, 100, 10, 6)){ pagination => + defining(Pagination(9, 100, 10, 6)) { pagination => assert(pagination.omitLeft == true) assert(pagination.omitRight == false) } @@ -28,7 +28,7 @@ describe("visibleFor") { it("should return true for visible pagination links") { - defining(Pagination(1, 100, 10, 6)){ pagination => + defining(Pagination(1, 100, 10, 6)) { pagination => assert(pagination.visibleFor(1) == true) assert(pagination.visibleFor(2) == true) assert(pagination.visibleFor(3) == true) @@ -40,7 +40,7 @@ assert(pagination.visibleFor(9) == false) assert(pagination.visibleFor(10) == true) } - defining(Pagination(5, 100, 10, 6)){ pagination => + defining(Pagination(5, 100, 10, 6)) { pagination => assert(pagination.visibleFor(1) == true) assert(pagination.visibleFor(2) == false) assert(pagination.visibleFor(3) == false) @@ -52,7 +52,7 @@ assert(pagination.visibleFor(9) == false) assert(pagination.visibleFor(10) == true) } - defining(Pagination(8, 100, 10, 6)){ pagination => + defining(Pagination(8, 100, 10, 6)) { pagination => assert(pagination.visibleFor(1) == true) assert(pagination.visibleFor(2) == false) assert(pagination.visibleFor(3) == false)