integration tests

doobie/src/it/scala/za/co/absa/fadb/doobie/DoobieMultipleResultFunctionTest.scala

@@ -10,9 +10,6 @@ import za.co.absa.fadb.doobie.DoobieFunction.DoobieMultipleResultFunction
 
 class DoobieMultipleResultFunctionTest extends AnyFunSuite with DoobieTest {
 
-  case class Actor(actorId: Int, firstName: String, lastName: String)
-  case class GetActorsQueryParameters(firstName: Option[String], lastName: Option[String])
-
   class GetActors(implicit schema: DBSchema, dbEngine: DoobiePgEngine)
     extends DoobieMultipleResultFunction[GetActorsQueryParameters, Actor] {
 
@@ -27,5 +24,4 @@ class DoobieMultipleResultFunctionTest extends AnyFunSuite with DoobieTest {
     val results = getActors.apply(GetActorsQueryParameters(Some("Pavel"), Some("Marek"))).unsafeRunSync()
     assert(results.contains(expectedResultElem))
   }
-
 }

doobie/src/it/scala/za/co/absa/fadb/doobie/DoobieOptionalResultFunctionTest.scala

@@ -10,8 +10,6 @@ import za.co.absa.fadb.doobie.DoobieFunction.DoobieOptionalResultFunction
 
 class DoobieOptionalResultFunctionTest extends AnyFunSuite with DoobieTest {
 
-  case class Actor(actorId: Int, firstName: String, lastName: String)
-
   class GetActorById(implicit schema: DBSchema, dbEngine: DoobiePgEngine)
     extends DoobieOptionalResultFunction[Int, Actor] {
 

doobie/src/it/scala/za/co/absa/fadb/doobie/DoobieSingleResultFunctionTest.scala

@@ -10,8 +10,6 @@ import za.co.absa.fadb.doobie.DoobieFunction.DoobieSingleResultFunction
 
 class DoobieSingleResultFunctionTest extends AnyFunSuite with DoobieTest {
 
-  case class CreateActorRequestBody(firstName: String, lastName: String)
-
   class CreateActor(implicit schema: DBSchema, dbEngine: DoobiePgEngine)
     extends DoobieSingleResultFunction[CreateActorRequestBody, Int] {
 
@@ -24,5 +22,4 @@ class DoobieSingleResultFunctionTest extends AnyFunSuite with DoobieTest {
   test("DoobieTest") {
     assert(createActor.apply(CreateActorRequestBody("Pavel", "Marek")).unsafeRunSync().isInstanceOf[Int])
   }
-
 }

doobie/src/it/scala/za/co/absa/fadb/doobie/DoobieSingleResultFunctionWithStatusSupportTest.scala

@@ -12,8 +12,6 @@ import za.co.absa.fadb.status.handling.implementations.StandardStatusHandling
 
 class DoobieSingleResultFunctionWithStatusSupportTest extends AnyFunSuite with DoobieTest {
 
-  case class CreateActorRequestBody(firstName: String, lastName: String)
-
   class CreateActor(implicit schema: DBSchema, dbEngine: DoobiePgEngine)
     extends DoobieSingleResultFunctionWithStatusSupport[CreateActorRequestBody, Int]
     with StandardStatusHandling {

doobie/src/it/scala/za/co/absa/fadb/doobie/DoobieTest.scala

@@ -6,8 +6,11 @@ import doobie.util.transactor.Transactor
 import za.co.absa.fadb.DBSchema
 
 trait DoobieTest {
-  import za.co.absa.fadb.naming.implementations.SnakeCaseNaming.Implicits._
+  case class Actor(actorId: Int, firstName: String, lastName: String)
+  case class GetActorsQueryParameters(firstName: Option[String], lastName: Option[String])
+  case class CreateActorRequestBody(firstName: String, lastName: String)
 
+  import za.co.absa.fadb.naming.implementations.SnakeCaseNaming.Implicits._
   object Runs extends DBSchema
 
   val printSqlLogHandler: LogHandler[IO] = new LogHandler[IO] {

slick/src/it/resources/application.conf

@@ -4,9 +4,9 @@ postgrestestdb = {
   properties = {
     serverName = "localhost"
     portNumber = "5432"
-    databaseName = "postgres"
+    databaseName = "movies"//"postgres"
     user = "postgres"
-    password = "changeme"
+    password = "postgres"
   }
   numThreads = 10
 }

slick/src/it/scala/za/co/absa/fadb/slick/Actor.scala

@@ -0,0 +1,3 @@
+package za.co.absa.fadb.slick
+
+case class Actor(actorId: Int, firstName: String, lastName: String)

slick/src/it/scala/za/co/absa/fadb/slick/ActorSlickConverter.scala

@@ -0,0 +1,17 @@
+package za.co.absa.fadb.slick
+
+import slick.jdbc.{GetResult, PositionedResult}
+
+/**
+ *  A trait representing a converter from a Slick PositionedResult to an Actor.
+ *  The trait is to be mixed into a SlickFunction returning an Actor.
+ */
+trait ActorSlickConverter {
+
+  protected def slickConverter: GetResult[Actor] = {
+    def converter(r: PositionedResult): Actor = {
+      Actor(r.<<, r.<<, r.<<)
+    }
+    GetResult(converter)
+  }
+}

slick/src/it/scala/za/co/absa/fadb/slick/SlickMultipleResultFunctionTest.scala

@@ -0,0 +1,35 @@
+package za.co.absa.fadb.slick
+
+import cats.implicits._
+import org.scalatest.funsuite.AnyFunSuite
+import slick.jdbc.SQLActionBuilder
+import za.co.absa.fadb.DBFunction.DBMultipleResultFunction
+import za.co.absa.fadb.DBSchema
+import za.co.absa.fadb.slick.FaDbPostgresProfile.api._
+
+import scala.concurrent.ExecutionContext.Implicits.global
+import scala.concurrent.duration.DurationInt
+import scala.concurrent.{Await, Future}
+
+class SlickMultipleResultFunctionTest extends AnyFunSuite with SlickTest {
+
+  class GetActors(implicit override val schema: DBSchema, val dbEngine: SlickPgEngine)
+    extends DBMultipleResultFunction[GetActorsQueryParameters, Actor, SlickPgEngine, Future]
+      with SlickFunction[GetActorsQueryParameters, Actor]
+      with ActorSlickConverter {
+
+    override def fieldsToSelect: Seq[String] = super.fieldsToSelect ++ Seq("actor_id", "first_name", "last_name")
+
+    override protected def sql(values: GetActorsQueryParameters): SQLActionBuilder = {
+      sql"""SELECT #$selectEntry FROM #$functionName(${values.firstName},${values.lastName}) #$alias;"""
+    }
+  }
+
+  private val getActors = new GetActors()(Runs, new SlickPgEngine(db))
+
+  test("SlickTest") {
+    val expectedResultElem = Actor(49, "Pavel", "Marek")
+    val results = getActors.apply(GetActorsQueryParameters(Some("Pavel"), Some("Marek")))
+    assert(Await.result(results, 5.seconds).contains(expectedResultElem))
+  }
+}

slick/src/it/scala/za/co/absa/fadb/slick/SlickOptionalResultFunctionTest.scala

@@ -0,0 +1,36 @@
+package za.co.absa.fadb.slick
+
+import cats.implicits._
+
+import scala.concurrent.ExecutionContext.Implicits.global
+import org.scalatest.funsuite.AnyFunSuite
+import slick.jdbc.SQLActionBuilder
+import za.co.absa.fadb.DBFunction.DBOptionalResultFunction
+import za.co.absa.fadb.DBSchema
+import za.co.absa.fadb.slick.FaDbPostgresProfile.api._
+
+import scala.concurrent.{Await, Future}
+import scala.concurrent.duration.DurationInt
+
+class SlickOptionalResultFunctionTest extends AnyFunSuite with SlickTest {
+
+  class GetActorById(implicit override val schema: DBSchema, val dbEngine: SlickPgEngine)
+    extends DBOptionalResultFunction[Int, Actor, SlickPgEngine, Future]
+      with SlickFunction[Int, Actor]
+      with ActorSlickConverter {
+
+    override def fieldsToSelect: Seq[String] = super.fieldsToSelect ++ Seq("actor_id", "first_name", "last_name")
+
+    override protected def sql(values: Int): SQLActionBuilder = {
+      sql"""SELECT #$selectEntry FROM #$functionName($values) #$alias;"""
+    }
+  }
+
+  private val getActorById = new GetActorById()(Runs, new SlickPgEngine(db))
+
+  test("SlickTest") {
+    val expectedResultElem = Some(Actor(49, "Pavel", "Marek"))
+    val results = getActorById.apply(49)
+    assert(Await.result(results, 5.seconds) == expectedResultElem)
+  }
+}

slick/src/it/scala/za/co/absa/fadb/slick/SlickTest.scala

@@ -0,0 +1,13 @@
+package za.co.absa.fadb.slick
+
+import slick.jdbc.JdbcBackend.Database
+import za.co.absa.fadb.DBSchema
+
+trait SlickTest {
+  case class GetActorsQueryParameters(firstName: Option[String], lastName: Option[String])
+
+  import za.co.absa.fadb.naming.implementations.SnakeCaseNaming.Implicits._
+  object Runs extends DBSchema
+
+  val db = Database.forConfig("postgrestestdb")
+}