start exam implementation: with the notate method, driven by test

build.gradle

@@ -23,6 +23,7 @@ version = '0.0.1-SNAPSHOT'
 subprojects {
     apply plugin: 'kotlin'
     apply plugin: 'org.junit.platform.gradle.plugin'
+    apply plugin: "org.jetbrains.kotlin.plugin.allopen"
 
     junitPlatform {
         filters {
@@ -35,7 +36,9 @@ subprojects {
     dependencies {
         compile("org.jetbrains.kotlin:kotlin-stdlib-jdk8")
         compile("org.jetbrains.kotlin:kotlin-reflect")
-        testCompile('org.jetbrains.spek:spek-api:1.1.5') {
+        compile group: 'io.arrow-kt', name: 'arrow-core', version: '0.7.2'
+        testCompile('org.jetbrains.spek:spek-api:1.1.5')
+        {
             exclude group: 'org.jetbrains.kotlin'
         }
         testRuntime('org.jetbrains.spek:spek-junit-platform-engine:1.1.5') {

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-4.8-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-4.4-bin.zip

interactors/src/main/kotlin/entities/Exam.kt

@@ -0,0 +1,14 @@
+package com.students.results.entities
+
+import arrow.core.Either
+import java.math.BigDecimal
+
+data class Exam(val id: Long) {
+    fun validateNotation(notation: BigDecimal): Either<InvalidNotationForThisExamException, Unit> =
+            when (notation) {
+                in (0.toBigDecimal()..20.toBigDecimal()) -> Either.right(Unit)
+                else -> Either.left(InvalidNotationForThisExamException("This notation, $notation, is not in bound"))
+            }
+}
+
+class InvalidNotationForThisExamException(msg: String?) : RuntimeException(msg)

interactors/src/main/kotlin/entities/Student.kt

@@ -0,0 +1,22 @@
+package com.students.results.entities
+
+import arrow.core.Either
+import java.math.BigDecimal
+
+typealias Notes = Map<Exam, BigDecimal>
+
+data class Student(val id: Long, val notes: Notes = emptyMap()) {
+    fun getNotation(exam: Exam): Either<NotEvaluatedException, BigDecimal> =
+            when {
+                notes.containsKey(exam) -> Either.right(notes.getValue(exam))
+                else -> Either.left(NotEvaluatedException())
+            }
+
+    fun notate(exam: Exam, note: BigDecimal): Either<InvalidNotationForThisExamException, Student> =
+            exam.validateNotation(note).map {
+                copy(id = id,
+                        notes = notes + mapOf(exam to note))
+            }
+}
+
+class NotEvaluatedException(msg: String? = null, throwable: Throwable? = null) : RuntimeException(msg, throwable)

interactors/src/main/kotlin/interactors/ExamsInteractor.kt

@@ -0,0 +1,6 @@
+package com.students.results.interactors
+
+import com.students.results.repository.ExamsRepository
+import com.students.results.services.Exams
+
+class ExamsInteractor(private val examsRepository: ExamsRepository) : Exams

interactors/src/main/kotlin/interactors/StudentsInteractor.kt

@@ -0,0 +1,22 @@
+package com.students.results.interactors
+
+import arrow.core.Either
+import arrow.core.flatMap
+import com.students.results.repository.ExamsRepository
+import com.students.results.repository.StudentsRepository
+import com.students.results.services.NotateExamException
+import com.students.results.services.Students
+import com.students.results.services.requests.NotateExam
+
+class StudentsInteractor(private val studentsRepository: StudentsRepository, private val examsRepository: ExamsRepository) : Students {
+
+    override fun notate(notateExam: NotateExam): Either<NotateExamException, Unit> =
+            studentsRepository.findStudentById(studentId = 1).flatMap { student ->
+                examsRepository.findExamById(examId = notateExam.examId).flatMap { exam ->
+                    student.notate(exam, notateExam.note).flatMap { updatedStudent ->
+                        studentsRepository.save(updatedStudent)
+                    }
+                }
+            }.mapLeft { NotateExamException(throwable = it) }
+
+}

interactors/src/main/kotlin/repository/ExamsRepository.kt

@@ -0,0 +1,9 @@
+package com.students.results.repository
+
+import arrow.core.Either
+import com.students.results.entities.Exam
+
+interface ExamsRepository {
+
+    fun findExamById(examId: Long): Either<NotFoundException, Exam>
+}

interactors/src/main/kotlin/repository/Repositories.kt

@@ -0,0 +1,8 @@
+package com.students.results.repository
+
+
+sealed class RepositoryException(msg: String? = null, throwable: Throwable? = null) : RuntimeException(msg, throwable)
+
+class NotFoundException(msg: String? = null, throwable: Throwable? = null) : RepositoryException(msg, throwable)
+class NotWrittenException(msg: String? = null, throwable: Throwable? = null) : RepositoryException(msg, throwable)
+class RepositoryNotAvailableException(msg: String? = null, throwable: Throwable? = null) : RepositoryException(msg, throwable)

interactors/src/main/kotlin/repository/StudentsRepository.kt

@@ -0,0 +1,10 @@
+package com.students.results.repository
+
+import arrow.core.Either
+import com.students.results.entities.Student
+
+interface StudentsRepository {
+
+    fun findStudentById(studentId: Long): Either<RepositoryException, Student>
+    fun save(student: Student): Either<RepositoryException, Unit>
+}

interactors/src/main/kotlin/services/Exams.kt

@@ -0,0 +1,6 @@
+package com.students.results.services
+
+interface Exams {
+}
+
+class NotateExamException(message: String? = null, throwable: Throwable? = null) : RuntimeException(message, throwable)

interactors/src/main/kotlin/services/Services.kt

@@ -0,0 +1,5 @@
+package services
+
+sealed class ServicesException(msg: String? = null, throwable: Throwable? = null) : RuntimeException(msg, throwable)
+
+class NotFoundException(msg: String? = null, throwable: Throwable? = null) : ServicesException(msg, throwable)

interactors/src/main/kotlin/services/Students.kt

@@ -0,0 +1,10 @@
+package com.students.results.services
+
+import arrow.core.Either
+import com.students.results.services.requests.NotateExam
+
+interface Students {
+
+    fun notate(notateExam: NotateExam): Either<NotateExamException, Unit>
+
+}

interactors/src/main/kotlin/services/requests/NotateExam.kt

@@ -0,0 +1,5 @@
+package com.students.results.services.requests
+
+import java.math.BigDecimal
+
+data class NotateExam(val examId: Long, val studentId: Long, val note: BigDecimal)

interactors/src/test/kotlin/entities/StudentTest.kt

@@ -0,0 +1,35 @@
+package entities
+
+import com.students.results.entities.Exam
+import com.students.results.entities.Student
+import org.amshove.kluent.shouldBe
+import org.amshove.kluent.shouldEqual
+import org.jetbrains.spek.api.Spek
+import org.jetbrains.spek.api.dsl.given
+import org.jetbrains.spek.api.dsl.it
+
+class StudentTest : Spek({
+
+    given("a student") {
+        val student = Student(id = 40L)
+        val exam = Exam(id = 50L)
+
+        it("getNot without note should returns NotEvaluatedException") {
+            student.getNotation(exam).isLeft() shouldBe true
+        }
+        it("notate an exam with 20 and get notation should return 20") {
+            student.notate(exam, "20".toBigDecimal()).apply {
+                isRight() shouldBe true
+                map {
+                    it.getNotation(exam).apply {
+                        isRight() shouldBe true
+                        map { it shouldEqual "20".toBigDecimal() }
+                    }
+                }
+            }
+        }
+        it("notate less than zero should fail to register note") {
+            student.notate(exam, "-1".toBigDecimal()).isLeft() shouldBe true
+        }
+    }
+})

interactors/src/test/kotlin/interactors/ExamsInteractorTest.kt

@@ -0,0 +1,7 @@
+package com.students.results.interactors
+
+import org.jetbrains.spek.api.Spek
+
+class ExamsInteractorTest : Spek({
+
+})

interactors/src/test/kotlin/interactors/StudentsInteractorTest.kt

@@ -0,0 +1,60 @@
+package com.students.results.interactors
+
+import arrow.core.Either
+import com.students.results.entities.Exam
+import com.students.results.entities.Student
+import com.students.results.repository.ExamsRepository
+import com.students.results.repository.StudentsRepository
+import com.students.results.services.requests.NotateExam
+import io.mockk.every
+import io.mockk.mockk
+import io.mockk.slot
+import io.mockk.verify
+import org.amshove.kluent.`should be`
+import org.amshove.kluent.shouldBe
+import org.amshove.kluent.shouldEqual
+import org.jetbrains.spek.api.Spek
+import org.jetbrains.spek.api.dsl.given
+import org.jetbrains.spek.api.dsl.it
+
+
+class StudentsInteractorTest : Spek({
+
+    val student = Student(id = 10L)
+    given("a student interactor") {
+
+        val studentSlot = slot<Student>()
+        val studentRepository = mockk<StudentsRepository>() {
+            every { findStudentById(1) } returns Either.right(student)
+            every { save(student = capture(studentSlot)) } returns Either.right(Unit)
+        }
+        val exam = Exam(id = 5)
+        val examsRepository = mockk<ExamsRepository>().apply {
+            every { findExamById(5) } returns Either.right(exam)
+        }
+        val studentsInteractor = StudentsInteractor(studentRepository, examsRepository)
+        studentsInteractor.notate20().apply {
+            it("should notate an existing exam with a note of 20") {
+                isRight() `should be` true
+            }
+            it("should retrieve student by his id") {
+                verify { studentRepository.findStudentById(1) }
+            }
+            it("should retrieve exam by id") {
+                verify { examsRepository.findExamById(5) }
+            }
+            it("should save student to the repository with the expected notation of 20 for this exam") {
+                studentSlot.captured.getNotation(exam).apply {
+                    isRight() shouldBe true
+                    map { it shouldEqual "20".toBigDecimal() }
+                }
+            }
+        }
+    }
+})
+
+private fun StudentsInteractor.notate20() = notate(NotateExam(
+        examId = 5,
+        studentId = 1,
+        note = "20".toBigDecimal()
+))

persistence/build.gradle

@@ -1,7 +1,18 @@
-
 apply plugin: 'kotlin-spring'
 
 dependencies {
-    compile project(':business-rules')
+    compile project(':interactors')
     compile group: 'org.springframework.data', name: 'spring-data-redis', version: '2.0.7.RELEASE'
+    testCompile 'it.ozimov:embedded-redis:0.7.2'
+    testCompile group: 'org.springframework', name: 'spring-test', version: '5.0.6.RELEASE'
+    testImplementation(
+            'org.junit.jupiter:junit-jupiter-api:5.1.0'
+    )
+    testRuntimeOnly(
+            'org.junit.jupiter:junit-jupiter-engine:5.1.0'
+    )
+}
+
+test {
+    useJUnitPlatform()
 }

persistence/src/main/kotlin/redis/configuration/RedisConfiguration.kt

@@ -0,0 +1,20 @@
+package com.students.results.redis.configuration
+
+import org.springframework.context.annotation.Bean
+import org.springframework.context.annotation.Configuration
+import org.springframework.data.redis.connection.jedis.JedisConnectionFactory
+import org.springframework.data.redis.core.RedisTemplate
+import org.springframework.data.redis.repository.configuration.EnableRedisRepositories
+
+@Configuration
+@EnableRedisRepositories
+class RedisConfiguration {
+
+    @Bean
+    fun connectionFactory() = JedisConnectionFactory()
+
+    @Bean
+    fun redisTemplate(jedisConnectionFactory: JedisConnectionFactory) = RedisTemplate<Any, Any>().apply {
+        connectionFactory = jedisConnectionFactory
+    }
+}

persistence/src/test/kotlin/embeded/redis/startup/EmbededRedisTest.kt

@@ -0,0 +1,37 @@
+package embeded.redis.startup
+
+import com.students.results.redis.configuration.RedisConfiguration
+import org.junit.jupiter.api.AfterAll
+import org.junit.jupiter.api.BeforeAll
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.TestInstance
+import org.junit.jupiter.api.TestInstance.*
+import org.junit.runner.RunWith
+import org.springframework.beans.factory.annotation.Autowired
+import org.springframework.test.context.ContextConfiguration
+import org.springframework.test.context.junit4.SpringRunner
+import redis.embedded.RedisServer
+
+@RunWith(SpringRunner::class)
+@ContextConfiguration(classes = [RedisConfiguration::class, RedisEmbededConfiguration::class])
+@TestInstance(Lifecycle.PER_CLASS)
+class EmbededRedisTest {
+
+    @Autowired
+    private lateinit var redisServer: RedisServer
+
+    @BeforeAll
+    fun beforeStart() {
+        redisServer.start()
+    }
+
+    @Test
+    fun runATEst(){
+        println("I am running")
+    }
+
+    @AfterAll
+    fun afterStart() {
+        redisServer.stop()
+    }
+}

persistence/src/test/kotlin/embeded/redis/startup/RedisEmbededConfiguration.kt

@@ -0,0 +1,12 @@
+package embeded.redis.startup
+
+import org.springframework.context.annotation.Bean
+import org.springframework.context.annotation.Configuration
+import redis.embedded.RedisServer
+
+@Configuration
+class RedisEmbededConfiguration {
+
+    @Bean
+    fun redisServer(): RedisServer = RedisServer(6379)
+}

settings.gradle

@@ -1,4 +1,4 @@
 rootProject.name = 'students-results'
 
-include 'business-rules', 'main', 'persistence'
+include 'interactors', 'main', 'persistence'