Merge pull request #8 from Cognifide/feature/new-approach-of-tests

New approach of tests.

.travis.yml

@@ -6,7 +6,7 @@ branches:
     - /^release.*$/
 
 jdk:
-  - oraclejdk8
+  - openjdk8
 
 before_install:
   - chmod +x gradlew

build.gradle.kts

@@ -32,8 +32,9 @@ subprojects {
 
         dependencies {
             "implementation"(kotlin("stdlib-jdk8"))
-            "implementation"("org.junit.jupiter:junit-jupiter-api:5.4.2")
-            "testRuntime"("org.junit.jupiter:junit-jupiter-engine:5.4.2")
+            "implementation"("org.junit.jupiter:junit-jupiter-api:5.5.1")
+            "implementation"("org.junit.jupiter:junit-jupiter-params:5.5.1")
+            "testRuntime"("org.junit.jupiter:junit-jupiter-engine:5.5.1")
 
             "implementation"("org.apache.commons:commons-lang3:3.8.1")
         }

core/build.gradle.kts

@@ -4,5 +4,11 @@ plugins {
 
 dependencies {
     implementation("io.rest-assured:rest-assured:4.0.0")
+    implementation("org.yaml:snakeyaml:1.19")
+    implementation("com.fasterxml.jackson.dataformat:jackson-dataformat-yaml:2.9.8")
+    implementation("com.fasterxml.jackson.core:jackson-databind:2.9.8")
+    implementation("com.fasterxml.jackson.module:jackson-module-kotlin:2.9.8")
     implementation("com.github.tomakehurst:wiremock-jre8:2.23.2")
+    implementation("org.junit.jupiter:junit-jupiter-api:5.5.1")
+    implementation("org.junit.jupiter:junit-jupiter-params:5.5.1")
 }

core/src/main/kotlin/com/cognifide/apmt/ArgumentsFactory.kt

@@ -0,0 +1,90 @@
+package com.cognifide.apmt
+
+import org.junit.jupiter.api.Assumptions
+import org.junit.jupiter.params.provider.Arguments
+
+fun createAllowed(testCases: List<TestCaseConfiguration>): List<Arguments> {
+    return toArguments(testCases.flatMap { createAllowed(it) }.distinct().sorted())
+}
+
+fun createDenied(testCases: List<TestCaseConfiguration>): List<Arguments> {
+    return toArguments(testCases.flatMap { createDenied(it) }.distinct().sorted())
+}
+
+private fun createAllowed(testCase: TestCaseConfiguration): List<UserAndPath> {
+    return createArguments(
+        testCase.paths,
+        testCase.allowedUsers,
+        testCase.deniedUsers,
+        testCase.allUsers,
+        testCase.allowedPairsPredicate,
+        testCase.deniedPairsPredicate
+    )
+}
+
+private fun createDenied(testCase: TestCaseConfiguration): List<UserAndPath> {
+    return createArguments(
+        testCase.paths,
+        testCase.deniedUsers,
+        testCase.allowedUsers,
+        testCase.allUsers,
+        testCase.deniedPairsPredicate,
+        testCase.allowedPairsPredicate
+    )
+}
+
+private fun createArguments(
+    paths: List<String>,
+    users: List<User>,
+    opposedUsers: List<User>,
+    allUsers: List<User>,
+    predicate: ((user: User, path: String) -> Boolean)?,
+    opposedPredicate: ((user: User, path: String) -> Boolean)?
+): List<UserAndPath> {
+    return when {
+        users.isNotEmpty() -> pairs(users, paths, predicate)
+        opposedUsers.isNotEmpty() && allUsers.isNotEmpty() -> {
+            val allPairs = pairs(allUsers, paths)
+            allPairs - pairs(opposedUsers, paths, opposedPredicate)
+        }
+        else -> listOf()
+    }
+}
+
+private fun toArguments(usersAndPaths: Collection<UserAndPath>): List<Arguments> {
+    val arguments = mutableListOf<Arguments>()
+    usersAndPaths.forEach { arguments.add(Arguments.of(it.user, it.path)) }
+
+    Assumptions.assumeFalse(arguments.isEmpty(), "No arguments")
+
+    return arguments.toList()
+}
+
+private fun pairs(
+    users: List<User>,
+    paths: List<String>,
+    predicate: ((user: User, path: String) -> Boolean)?
+): List<UserAndPath> {
+    val pairs = pairs(users, paths)
+    if (predicate != null) {
+        return pairs.filter { predicate(it.user, it.path) }
+    }
+    return pairs
+}
+
+private fun pairs(users: List<User>, paths: List<String>): List<UserAndPath> {
+    val results = mutableListOf<UserAndPath>()
+    for (user in users) {
+        for (path in paths) {
+            results.add(UserAndPath(user, path))
+        }
+    }
+    return results.toList()
+}
+
+data class UserAndPath(val user: User, val path: String) : Comparable<UserAndPath> {
+
+    override fun compareTo(other: UserAndPath): Int {
+        return this.user.username.compareTo(other.user.username)
+    }
+}

core/src/main/kotlin/com/cognifide/apmt/TestCase.kt

@@ -0,0 +1,6 @@
+package com.cognifide.apmt
+
+interface TestCase {
+
+    fun toTestCaseConfiguration(): TestCaseConfiguration
+}

core/src/main/kotlin/com/cognifide/apmt/TestCaseConfiguration.kt

@@ -1,19 +1,40 @@
 package com.cognifide.apmt
 
-import kotlin.reflect.KFunction2
 
-class TestCaseConfiguration(
-    var name: String = "",
-    var test: KFunction2<String, String, Unit>? = null,
-    internal val paths: MutableList<String> = mutableListOf(),
-    internal val users: MutableList<User> = mutableListOf()
+class TestCaseConfiguration @JvmOverloads constructor(
+    internal var allowedUsers: List<User> = listOf(),
+    internal var deniedUsers: List<User> = listOf(),
+    internal var paths: List<String> = listOf(),
+    internal var allUsers: List<User> = listOf(),
+    internal var allowedPairsPredicate: ((user: User, path: String) -> Boolean)? = null,
+    internal var deniedPairsPredicate: ((user: User, path: String) -> Boolean)? = null
 ) {
 
-    fun addPath(path: String) {
-        paths.add(path)
+    fun allUsers(allUsers: Array<out User>) {
+        this.allUsers = allUsers.toList()
     }
 
-    fun addUser(user: User) {
-        users.add(user)
+    fun allUsers(allUsers: List<User>) {
+        this.allUsers = allUsers
+    }
+
+    fun paths(vararg paths: String) {
+        this.paths = paths.toList()
+    }
+
+    fun allowedUsers(vararg users: User) {
+        this.allowedUsers = users.toList()
+    }
+
+    fun deniedUsers(vararg users: User) {
+        this.deniedUsers = users.toList()
+    }
+
+    fun allowedPairsPredicate(predicate: (user: User, path: String) -> Boolean) {
+        this.allowedPairsPredicate = predicate
+    }
+
+    fun deniedPairsPredicate(predicate: (user: User, path: String) -> Boolean) {
+        this.deniedPairsPredicate = predicate
     }
 }

core/src/main/kotlin/com/cognifide/apmt/User.kt

@@ -4,5 +4,5 @@ interface User {
 
     val username: String
     val password: String
-    val groups: List<Group>
+
 }

core/src/main/kotlin/com/cognifide/apmt/actions/Action.kt

@@ -3,9 +3,9 @@ package com.cognifide.apmt.actions
 import io.restassured.response.Response
 
 interface Action {
-    fun prepare(): Response?
-    fun execute(): Response?
-    fun undo(): Response?
+    fun prepare(): Response? = null
+    fun execute(): Response
+    fun undo(): Response? = null
 
     fun successCode(): Int
     fun failureCode(): Int

core/src/main/kotlin/com/cognifide/apmt/actions/ActionContext.kt

@@ -11,13 +11,15 @@ object ActionContext {
     fun basicRequestSpec(user: User, instance: Instance): RequestSpecification {
         return RestAssured
             .given()
+            .headers(instance.headers)
             .header(CSRF_TOKEN, obtainCsrfToken(user, instance))
             .auth().preemptive().basic(user.username, user.password)
     }
 
     private fun obtainCsrfToken(user: User, instance: Instance): String {
         return RestAssured
             .given()
+            .headers(instance.headers)
             .auth().preemptive().basic(user.username, user.password)
             .`when`()
             .get(instance.url + CSRF_ENDPOINT)

core/src/main/kotlin/com/cognifide/apmt/actions/asset/CreateAsset.kt

@@ -0,0 +1,31 @@
+package com.cognifide.apmt.actions.asset
+
+import com.cognifide.apmt.User
+import com.cognifide.apmt.actions.Action
+import com.cognifide.apmt.actions.ActionContext
+import com.cognifide.apmt.config.Instance
+import io.restassured.response.Response
+
+class CreateAsset(
+    private val instance: Instance,
+    private val user: User,
+    private val path: String
+) : Action {
+
+    override fun execute(): Response {
+        return ActionContext.basicRequestSpec(user, instance)
+            .formParam("jcr:primaryType", "sling:OrderedFolder")
+            .formParam("jcr:content/jcr:primaryType", "nt:unstructured")
+            .formParam("jcr:content/jcr:title", "Test Title")
+            .`when`()
+            .post(instance.url + path)
+    }
+
+    override fun undo(): Response? {
+        return ActionContext.basicRequestSpec(user, instance)
+            .delete(instance.url + path)
+    }
+
+    override fun successCode(): Int = 200
+    override fun failureCode(): Int = 404
+}

core/src/main/kotlin/com/cognifide/apmt/actions/asset/EditAsset.kt

@@ -0,0 +1,24 @@
+package com.cognifide.apmt.actions.asset
+
+import com.cognifide.apmt.User
+import com.cognifide.apmt.actions.Action
+import com.cognifide.apmt.actions.ActionContext
+import com.cognifide.apmt.config.Instance
+import io.restassured.response.Response
+
+class EditAsset(
+    private val instance: Instance,
+    private val user: User,
+    private val path: String
+) : Action {
+
+    override fun execute(): Response {
+        return ActionContext.basicRequestSpec(user, instance)
+            .formParam("jcr:title", "Some Title")
+            .`when`()
+            .post(instance.url + path)
+    }
+
+    override fun successCode(): Int = 200
+    override fun failureCode(): Int = 500
+}

core/src/main/kotlin/com/cognifide/apmt/actions/asset/RemoveAsset.kt

@@ -0,0 +1,22 @@
+package com.cognifide.apmt.actions.asset
+
+import com.cognifide.apmt.User
+import com.cognifide.apmt.actions.Action
+import com.cognifide.apmt.actions.ActionContext
+import com.cognifide.apmt.config.Instance
+import io.restassured.response.Response
+
+class RemoveAsset(
+    private val instance: Instance,
+    private val user: User,
+    private val path: String
+) : Action {
+
+    override fun execute(): Response {
+        return ActionContext.basicRequestSpec(user, instance)
+            .delete(instance.url + path)
+    }
+
+    override fun successCode(): Int = 204
+    override fun failureCode(): Int = 403
+}