En la entrada anterior, Inyección de dependencias en programación funcional I, realicé la descripción de cómo se realizaba la inyección de funciones en programación funcional en lenguaje Scala; en la presente entrada, Inyección de dependencias en programación funcional II, modularizaré el código existente en la primera entrada organizando el código con una perspectiva orientada a objetos sin perder el aspecto funcional.
La vista estática del problema es la definida en el diagrama de clases de la siguiente imagen:
Los tipos utilizados en el ejemplo son los siguientes:
import cats.syntax.either._
object typesEjem2{
type MensajeError = String
type GetComponent1 = (String) => Either[MensajeError, String]
type GetComponent2 = (Int) => Either[MensajeError, Int]
type ResponseService = Either[MensajeError, String]
type ParameterString = String
type ParameterInt = Int
type BusinessService = (GetComponent1, GetComponent2) => ParameterString => ResponseService
}
La definición de los componentes de negocio del ejemplo son los representados por los objetos Component1 y Component2. Respecto al ejemplo de la entrada anterior, se han definido las funciones dentro de un objeto con lo cual modularizamos la funcionalidad. El snippet del código de los componentes es el siguiente:
object Component1{
import typesEjem2._
val response1: MensajeError = "Error en Response1"
val doSomething: GetComponent1 = (elem: String) => {
elem.length match {
case lengthElem: Int if lengthElem > 0 => (elem + " modificado").asRight
case _ => response1.asLeft
}
}
}
object Component2{
import typesEjem2._
val response2: MensajeError = "Error en Response2"
val doSomething: GetComponent2 = (num: Int) => {
num match {
case elem: Int if elem > 0 => elem.asRight
case _ => response2.asLeft
}
}
}
La definición del servicio de negocio del ejemplo es el definido por el objeto Service. La estrategia de modularización es la misma que con los componentes. El snippet del código del servicio es el siguiente:
object Service{
import typesEjem2._
val doBusinessActivity: BusinessService = (objComp1, objComp2) => (msg) => {
for {
respon1 <- objComp1 (msg)
respon2 <- objComp2(msg.length)
} yield {
respon1 + "-" + respon2
}
}
}
La aplicación de ejemplo que usa los anteriores elementos es la siguiente:
object Ejem2DependencyInyectorApp extends App {
def ejemplo1(): Unit = {
val message1 = "Mensaje de prueba"
Service.doBusinessActivity(Component1.doSomething, Component2.doSomething)(message1) match {
case Right(msg) => println(s"Test1=${msg}")
case Left(error) => println(error)
}
val message2 = ""
Service.doBusinessActivity(Component1.doSomething, Component2.doSomething)(message2) match {
case Right(msg) => println(s"Test2=${msg}")
case Left(error) => println(error)
}
}
ejemplo1()
}
La salida por consola es la siguiente:
Test1=Mensaje de prueba modificado-17 Error en Response1
La definición de los test del servicio de negocio descrito en el ejemplo es el siguiente:
import org.scalatest.{Matchers, WordSpec}
import es.ams.dependencyinyector.typesEjem2.{GetComponent1, GetComponent2}
import cats.syntax.all._
class Ejem2DependecyInyectorTest extends WordSpec with Matchers {
"Example Mock" should {
"Example OK" in {
val msg: String = "prueba"
val result: String = Service.doBusinessActivity(Component1.doSomething, Component2.doSomething)(msg) match {
case Right(msg) => { println(msg); msg}
case Left(error) => error
}
result shouldBe(msg + " modificado-6")
}
"Example OK: mock component1" in {
val funcGetResponse1Mock: GetComponent1 = (num: String) => "mock".asRight
val msg: String = "prueba"
val result: String = Service.doBusinessActivity(funcGetResponse1Mock, Component2.doSomething)(msg) match {
case Right(msg) => { println(msg); msg}
case Left(error) => error
}
assert(result.length > 0)
assert(result.equals("mock-6"))
}
"Example OK: mock component2" in {
val funcComponent2: GetComponent2 = (num: Int) => 0.asRight
val msg: String = "prueba"
val result: String = Service.doBusinessActivity(Component1.doSomething, funcComponent2)(msg) match {
case Right(msg) => { println(msg); msg}
case Left(error) => error
}
assert(result.length > 0)
}
"Example OK: mock component1 and mock component2" in {
val funcGetResponse1Mock: GetComponent1 = (num: String) => "mock".asRight
val funcGetResponse2Mock: GetComponent2 = (num: Int) => 0.asRight
val msg: String = "prueba"
val result: String =Service.doBusinessActivity(funcGetResponse1Mock, funcGetResponse2Mock)(msg) match {
case Right(msg) => { println(msg); msg}
case Left(error) => error
}
assert(result.length > 0)
assert(result.equals("mock-0"))
}
}
}
En esta entrada he realizado la modularización del código definido en la entrada, Inyección de dependencias en programación funcional I; en la siguiente entrada, subiré el nivel de abstracción y describiré el mismo problema utilizando la mónada Reader.
Álvaro Monsalve Serrano 