Continuando con el segundo artículo de la serie con título Kotlin «SpringBoot, Docker y DockerCompose II: test unitarios» en el cual me centraré en cómo definir pruebas unitarias. En la anterior entrada, «Kotlin, SpringBoot, Docker y DockerCompose I», realicé una descripción de una aplicación básica de ejemplo.

La serie está compuesta de tres entradas ordenadas de forma cronológica:

• «Kotlin, SpringBoot, Docker y DockerCompose I».- descripción del funcionamiento de la aplicación y los elementos básicos de funcionamiento.
• «Kotlin, SpringBoot, Docker y DockerCompose II: test unitarios».- descripción de cómo se realizan test unitarios en SpringBoot con Kotlin.
• «Kotlin, SpringBoot, Docker y DockerCompose III: docker y docker-compose».-descripción de la dockerización de la aplicación con Docker u DockerCompse.

La estructura del artículo está compuesto por los siguientes puntos:

1. Test unitarios de controladores
2. Test unitarios de servicios
3. Test unitarios de repositorios

Para la realización de pruebas unitarias es necesario definir un conjunto de dependencias en el fichero de configuración de Gradle build.gradle.kts. Las dependencias necesarias son las siguientes:

testImplementation("org.springframework.boot:spring-boot-starter-test")
testImplementation("org.springframework.security:spring-security-config")
testImplementation("org.springframework.security:spring-security-test")
testImplementation("com.nhaarman.mockitokotlin2:mockito-kotlin:2.1.0")

Para realizar las pruebas unitarias es necesario tener definido el fichero con las propiedades para el entorno de pruebas; en el ejemplo, el contenido necesario del fichero application.properties es el siguiente:

spring.datasource.driver-class-name=org.h2.Driver
spring.datasource.url=jdbc:h2:mem:db;DB_CLOSE_DELAY=-1
spring.datasource.username=sa
spring.datasource.password=
kotlindocker.title=ExampleKotlinDocker
kotlindocker.banner.title=Warning
kotlindocker.banner.content=Kotlin application witth docker.

Las pruebas unitarias consiste en realizar test sobre un componente determinado. Si el componente tiene relaciones de asociación, o bien, usa elementos con una funcionalidad concreta, se puede declarar su resultado para realizar la prueba; estos casos, se emplean objetos mock para dichas pruebas.

1.- Test unitarios de controladores

Para definir una prueba unitaria de un controlador, en nuestro caso AppController, definiremos una clase de Test. La clase se test -AppControllerTest- debe de estar declarada con las siguientes anotaciones: @RunWith, @AutoConfigureMockMvc y @SpringBootTest.

La clase AppControllerTest dede tener definida la inyección de las entidades WebApplicationContext y MockMvc. Además, se definen la declaración de los elementos necesarios para moquear, en nuestro caso, la clase BusinessService mediante la anotación @MockBean.

La definición de un test se realiza definiendo funciones con la anotación @Test. En el cuerpo de la función, se declara el comportamiento del objeto moquedo, se lanza la petición al objeto a probar, en nuestro caso, una petición HTTP al enppoint /business/operation1 con los datos necesarios; y, para finalizar, se realiza el chequeo del resultado con las funciones del objeto MarcherAssert. El snippet del código es el siguiente:

@RunWith(SpringRunner::class)
@AutoConfigureMockMvc
@SpringBootTest
class AppControllerTest {
  @Autowired
  private lateinit var webApplicationContext: WebApplicationContext
  @Autowired
  private lateinit var mockMvc: MockMvc
  @MockBean
  private lateinit var businessService: BusinessService
  @org.junit.Before
  fun setup() {
    mockMvc = MockMvcBuilders
      .webAppContextSetup(webApplicationContext)
      .build()
  }
  @Test
  fun `AppControllerTest operation1`(){
    val responseOperation1 = BusinessServiceResponse(message = "MessageTest")
    whenever(businessService.operationBusiness1( any() )).thenReturn( responseOperation1 )
    val result = mockMvc.perform( MockMvcRequestBuilders.get("/business/operation1").accept(MediaType.APPLICATION_JSON) )
      .andExpect(MockMvcResultMatchers.status().isOk)
      .andExpect(MockMvcResultMatchers.content().contentType(MediaType.APPLICATION_JSON))
      .andReturn()
    MatcherAssert.assertThat(result.response.status, CoreMatchers.`is`(HttpStatus.OK.value()))
    verify(businessService).operationBusiness1( any() )
  }
}

2.- Test unitarios de servicios

La declaración de las pruebas unitarias de un servicio de negocio, sigue la misma línea que el de un controlador. En el ejemplo, definiré una prueba unitaria de la operación definida en el
servicio de negocio.

La diferencia radica en lo siguiente: los elementos que deben de ser moquedos, se declaran con la anotación @Mock; y, para el elemento a probar, se emplea la anotación @InjectMocks. La definición de la clase de test está definida exclusivamente con la anotación @RunWith(MockitoJUnitRunner::class). El snippet de la clase es el siguiente:

@RunWith(MockitoJUnitRunner::class)
class BusinessServiceTest {
  @Mock
  private lateinit var authorRepository: AuthorRepository
  @InjectMocks
  private lateinit var businessService: BusinessService
  @Test
  fun `operation1`(){
    val authorMock = Author(login = "loginTest", firstname = "firstNameTest", lastname = "lastnameTest")
    whenever(authorRepository.findByLogin( any() )).thenReturn(
      authorMock
    )
    val request = BusinessServiceRequest(login = "Param1")
    val result = businessService.operationBusiness1(request)
    MatcherAssert.assertThat(result.message, CoreMatchers.`is`( "Param1-" + authorMock.login ))
    verify(authorRepository).findByLogin( any() )
  }
}

3.- Test unitarios de repositorios

La definición de las clases de test de un repositorio deben de tener la anotación @DataJpaTest y, como atributo, la definición de inyección de dependecia de los repositorios a probar. En nuestro caso, definiremos la referencia al repositorio ArticleRepository y, por otro lado, la referencia al EntityManager de test. La prueba de una operación se define en una función creando los datos de entrada, consulta al repositorio y verificación del resultado. El snippet con el código de ejemplo es el siguiente:

@DataJpaTest
class ArticleRepositoryTest {
  @Autowired
  private lateinit var entityManager: TestEntityManager
  @Autowired
  private lateinit var articleRepository: ArticleRepository
  @Test
  fun `When findByIdOrNull then return Article`() {
    val juergen = Author("loginUserTest", "firstnameTest", "lastnameTest")
    val juergenInserted = entityManager.persist(juergen)
    assertThat(juergenInserted).isNotNull
    val article = Article("titleTest", "headLineTest", "ContentTest", juergen)
    val articleInserted = entityManager.persist(article)
    assertThat(articleInserted).isNotNull
      entityManager.flush()
    val found = articleRepository.findByIdOrNull(article.id!!)
    assertThat(found).isEqualTo(article)
  }
}

Para el lector interesado en el código del proyeceto puede acceder al siguiente enlace

En la siguiente entrada, «Kotlin, SpringBoot, Docker y DockerCompose III: docker y docker-compose», describiré como realizar test unitarios de los elementos de la aplicación.

Inicio una serie de entradas cuya finalidad es la creación de una aplicación sencilla con SpringBoot desarrollada en lenguaje Kotlin, además, pretendo dockerizar la aplicación con Docker y Docker DockerCompose.

La serie está compuesta de tres entradas ordenadas de forma cronológica:

• «Kotlin, SpringBoot, Docker y DockerCompose I».- descripción del funcionamiento de la aplicación y los elementos básicos de funcionamiento.
• «Kotlin, SpringBoot, Docker y DockerCompose II: test unitarios».- descripción de cómo se realizan test unitarios en SpringBoot con Kotlin.
• «Kotlin, SpringBoot, Docker y DockerCompose III: docker y docker-compose».-descripción de la dockerización de la aplicación con Docker u DockerCompse.

La aplicación define un servicio REST basada en un dominio para la gestión de artículos y sus autores. Se define una operación ficticia para integrar los componentes de la arquitectura software.

La estructura del artículo está compuesto por los siguientes puntos:

1. Definición de dependencias y creación del proyecto
2. Modelo de entidad
3. Capa de persistencia
4. Capa de servicio
5. Capa controladora
6. Aplicación
7. Configuración de base de datos
8. Arranque

1.-Definición de dependencias y creación del proyecto

La gestión de dependencias del proyecto la realiza Gradle. Las dependencias más importantes son: spring-boot-starter-data-jpa, spring-boot-starter-web, spring-boot-devtools, spring-boot-configuration-processor, h2 y mysql-connector-java

La versión de SpringBoot es la 2.2.7.RELEASE y el dependency-manager es la 1.0.9.RELEASE

2.-Modelo de entidad

La aplicación define dos entidades: Artículos y Autor. Un Autor está compuesto de los siguientes atributos: login, firstname, lastname. Un Artículo está compuesto por los siguientes atributos: title, headline, content, autor, slug y addedAt. Un Artículo está escrito por un Autor y, éste, puede escribir varios Artículos.

El snippet con las definición de las entidades es el siguiente:

@Entity
class Author(
  var login: String,
  var firstname: String,
  var lastname: String,
@Id @GeneratedValue var id: Long? = null)
@Entity
class Article(
  var title: String,
  var headline: String,
  var content: String,
  @ManyToOne var author: Author,
  var slug: String = title.toSlug(),
  var addedAt: LocalDateTime = LocalDateTime.now(),
  @Id @GeneratedValue var id: Long? = null)

La definición de las relaciones entre entidades se utilizan las siguientes anotaciones: @Entity, para definir las clases que definen una entidad; @ManyToOne, para definir las relaciones uno a muchos; y, @Id y @GeneratedValue, para definir un identificador único.

3.- Capa de persistencia

Los componentes de persistencia están basados en el interfaz CrudRepository de Spring JPA. Defino dos repositorios: ArticleRepository, para las operaciones sobre la entidad Article; y,
AuthorRepository, para las operaciones sobre la entidad Author. El snippet con los repositorios es el siguiente:

import com.example.ejem1kotlindocker.entity.Article
import com.example.ejem1kotlindocker.entity.Author
import org.springframework.data.repository.CrudRepository
interface ArticleRepository: CrudRepository<Article, Long> {
  fun findBySlug(slug: String): Article?
  fun findAllByOrderByAddedAtDesc(): Iterable<Article>
}
interface AuthorRepository: CrudRepository<Author, Long> {
  fun findByLogin(login: String): Author?
}

Las operaciones sobre las entidades son operaciones de búsqueda basadas en los atributos de cada entidad.

4.- Capa de servicio

La capa de servicios es aquella que define los componentes con las operaciones de negocio las cuáles utilizan los repositorios o cualquier otro componente. En el ejemplo, se define un único servicio con una operación y los DTO para la funcionalidad requerida. El snippet del servicio es el siguiente:

@Service
class BusinessService {
  companion object {
    @Suppress("JAVA_CLASS_ON_COMPANION")
    private val logger = LoggerFactory.getLogger(javaClass.enclosingClass)
  }

  @Autowired
  private lateinit var authorRepository: AuthorRepository

  @Transactional
  fun operationBusiness1(request: BusinessServiceRequest): BusinessServiceResponse {
    logger.info("[**] BusinessService.operation1. Request=${request}")
    val loginRequest = authorRepository.findByLogin(request.login)
    val stringResponse = StringBuilder()
    stringResponse.append(request.login)
    stringResponse.append("-")
    stringResponse.append(loginRequest!!.login)
    val result = BusinessServiceResponse(message = stringResponse.toString())
    logger.info("[**] BusinessService.operation1. result=${result}")
    return result
  }
}
data class BusinessServiceRequest(val login: String)
data class BusinessServiceResponse(val message: String)

En el snippet anterior, se muestra el servicio BusinessService que define una inyección de dependencia con el repositorio AuthorRepository, empleando la anotación @Autowired; se define una función de negocio operationBusiness1 transaccional al emplear la anotación @Transactional; se define un elemento de logger y los DTO de entrada y salida de de la operación de servicio operationBusiness1.

5.- Capa controladora

La capa controladora es aquella capa en la cual definimos los controladores REST de la aplicación. La capa controladora debe de definir una inyección de dependencia del servicio necesario para la ejecución de la operación de negocio. En nuestro caso, se define el controlador AppController con una dependecia al servicio BusinessService.

El snippet del controlador AppController es el siguiente:

import com.example.ejem1kotlindocker.service.BusinessService
import com.example.ejem1kotlindocker.service.BusinessServiceRequest
import com.example.ejem1kotlindocker.service.BusinessServiceResponse
import org.slf4j.LoggerFactory
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.RequestMapping
import org.springframework.web.bind.annotation.RestController
@RestController
@RequestMapping("business")
class AppController {
  companion object {
    @Suppress("JAVA_CLASS_ON_COMPANION")
    private val logger = LoggerFactory.getLogger(javaClass.enclosingClass)
  }

  @Autowired
  private lateinit var businessService: BusinessService

  @GetMapping("operation1")
  fun operation1(): BusinessServiceResponse {
    logger.info("[*] AppController.operation1.")
    val request = BusinessServiceRequest("ParamTest")
    return businessService.operationBusiness1(request)
  }
}

El controlador REST queda definido en la clase AppController por las anotaciones @RestController y @RequestMapping con el String «business». La funcionalidad del servicio de negocio se define con la anotación @GetMapping con la cual definimos una operación REST de tipo GET. Además, la clase define el atributo businessService con la inyección de dependencia utilizando la anotación @Autowired. Para finalizar e igual que el servicio, se utiliza un elemento para escribir trazas de log.

6.- Aplicación

La aplicación SpringBoot queda definida por la clase Ejem1kotlindockerApplication la cual queda definida con la apnotación @SpringBootApplication. La anotación @EnableConfigurationProperties define la relación de la clase con las propiedades de la misma, referenciando a la clase Ejem1kotlindockerProperties. La clase Ejem1kotlindockerProperties realiza la carga de las propiedades del fichero application.properties. El snippet de la clase es la siguiente:

import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.context.properties.EnableConfigurationProperties
import org.springframework.boot.runApplication

@SpringBootApplication
@EnableConfigurationProperties(Ejem1kotlindockerProperties::class)
class Ejem1kotlindockerApplication{}
fun main(args: Array<String>) {
  runApplication<Ejem1kotlindockerApplication>(*args){}
}

7.- Configuración de base de datos

La configuración de base de datos la realizamos en la clase Ejem1kotlindockerConfiguration. La clase define la carga de los datos de configuración desde el fichero application.properties y la definición de inicialización de unos datos iniciales en la base de datos en la función databaseInitializer.

Por otra parte, se definen dos Profile de trabajo: local, para la ejecución de la aplicación con una base de datos MySQL;y, dev, para definir la configuración a una base de datos al trabajar con el docker-compose. El snippet de la clase configuración es el siguiente:

@Configuration
@ConfigurationProperties("spring.datasource")
@SuppressWarnings("unused")
class Ejem1kotlindockerConfiguration{
  companion object {
    @Suppress("JAVA_CLASS_ON_COMPANION")
    private val logger = LoggerFactory.getLogger(javaClass.enclosingClass)
  }
  @Value("\${spring.datasource.driver-class-name}")
  private lateinit var driverClassName: String
  @Value("\${spring.datasource.url}")
  private lateinit var url: String
  @Value("\${spring.datasource.username}")
  private lateinit var username: String
  @Value("\${spring.datasource.password}")
  private lateinit var password: String
  @Profile("local")
  @Bean
  fun localDatabaseConnection(): String {
    println("DB connection form Local - MySQL")
    logger.info("[*] DriverClassName=${driverClassName}")
    logger.info("[*] URL=${url}")
    logger.info("[*] UserName=${username}")
    return "DB Connection for Local - MySQL"
  }
  @Profile("dev")
  @Bean
  fun devDatabaseConnection(): String {
    println("DB connection form Local - MySQL")
    logger.info("[*] DriverClassName=${driverClassName}")
    logger.info("[*] URL=${url}")
    logger.info("[*] UserName=${username}")
    return "DB Connection for Local - MySQL"
  }
  @Bean
  fun databaseInitializer(authorRepository: AuthorRepository,
    articleRepository: ArticleRepository) = ApplicationRunner {
    val smaldini = authorRepository.save(Author("ParamTest", "AuthorTest", "lastNameTest"))
    articleRepository.save(Article(
      title = "Articule1",
      headline = "Headline1",
      content = "Content1",
      author = smaldini
   ))
   articleRepository.save(Article(
     title = "Articule2",
     headline = "Headline2",
     content = "Content3",
     author = smaldini
   ))
  }
}

Los datos iniciales que se crean en la base de datos corresponden con dos elementos de la entidad Article.

8.- Arranque

Para arrancar la aplicación en un entorno local, es decir utilizando una base de datos H2, se ejecuta el siguiente comando ubicados en
la carpeta principal del proyecto:

./gradlew bootRun

Si queremos ejecutar la aplicación utilizando la configuración existente en el profile local, ejecutamos
el siguiente comando unicados en la carpeta principal del proyecto:

SPRING_PROFILES_ACTIVE=local ./gradlew bootRun

Para verificar el correcto funcionamiento del servicio, ejecutamos el siguiente comando curl:

curl http://localhost:8080/kotlindocker/business/operation1

La salida pos consola es la siguiente:

{"message":"ParamTest-ParamTest"}

 

Para el lector interesado en el código del proyeceto puede acceder al siguiente enlace

En la siguiente entrada, «Kotlin, SpringBoot, Docker y DockerCompose II: test unitarios«, describiré como realizar test unitarios de los elementos de la aplicación.