ASP .NET Core vs Spring Boot: ¿Cuál elegir?

En este post hablaremos de dos de las herramientas más populares y utilizadas para el desarrollo web. Por un lado, ASP (Active Server Pages) .Net Core y por el otro, Spring Boot. Ambas con sus seguidores, ambas con sus detractores. Ambas con sus pros y contras.

Empecemos con ASP .Net Core. Un framework desarrollado por la malévola empresa Microsoft (¿broma?) enfocada en la construcción de aplicaciones web. Unifica a ASP.NET MVC y ASP.NET Web API. Además de ser Open Source y multiplataforma. Además incluye Blazor, útil para desarrolladores que no quieren aprender Javascript (broma).

La documentación oficial nos dice:

".NET es una plataforma para desarrolladores formada por herramientas, lenguajes de programación y bibliotecas para crear una gran variedad de aplicaciones. ASP.NET Core amplía la plataforma para desarrolladores de .NET con herramientas y bibliotecas específicas para compilar aplicaciones web".

Si quieres instalar paquetes adicionales es necesario usar Nuget.

Actualmente existe infinidad de documentación oficial y no oficial, vídeos en Youtube, TikTok, etc. sobre esta herramienta. Además de no olvidar de libros, blogs y tutoriales en la red de redes.

Continuando con Spring Boot (no confundir con Spring Framework), la cual es una herramienta que ha facilitado el desarrollo web para los programadores Java (sic). Nos permite crear microservicios y aplicaciones web de una manera más sencilla a como se hacía antes con miles de configuraciones XML que ahogaban al pobre programador.

Spring Boot es una extensión de la plataforma Spring Framework que prioriza la configuración sobre la convención, con el objetivo de minimizar las preocupaciones de configuración al crear aplicaciones basadas en Spring. Dejando al programador ocupado con cosas más importantes (y menos tediosas).

Es importante notar que Spring Boot es un módulo basado en Spring Framework.

Principales características

ASP .Net Core:

• Experiencia de desarrollo sin compilación (es decir, la compilación es continua, de modo que el desarrollador no tiene que invocar el comando de compilación). 
• Framework modular distribuido como paquetes NuGet Entorno de ejecución optimizado para la nube (optimizado para Internet).
• Compatibilidad con diversos sistemas operativos mediante la interfaz web abierta para .NET (OWIN). 
• Un sistema de configuración basado en entornos y preparado para la nube.
• Una canalización de solicitudes HTTP ligera y modular.
• Crea y ejecuta aplicaciones ASP .Net Core multiplataforma en Windows, Mac y Linux. De código abierto y centrado en la comunidad. 
• Control de versiones de aplicaciones en paralelo al usar .NET como destino. 
• Soporte integrado para inyección de dependencias. 
• Seguridad mejorada en comparación con Asp.Net.

Spring Boot

• Desarrollo simplificado. 
• Convención sobre configuración. 
• Evitar escribir código reutilizable o configurar XML. 
• Preparación para la producción. 
• Arquitectura de microservicios. 
• Flexibilidad. 
• Programación reactiva. 

Pros y contras

ASP.NET Core

Pros:

• Alto rendimiento gracias a Kestrel y compilación nativa. 
•  Integración fluida con Azure y servicios Microsoft. Seguridad robusta con Identity y autenticación integrada. 
•  Multiplataforma (Windows, Linux, macOS).

Contras:

• Comunidad más pequeña fuera del ecosistema Microsoft. 
• Curva de aprendizaje si vienes de otros stacks (como Java). 
• Menos flexibilidad en comparación con Spring Boot en algunos patrones arquitectónicos.

Spring Boot

Pros:

• Rápido desarrollo con configuración automática y amplia comunidad. 
• Gran ecosistema: Spring Cloud, Spring Security, etc. 
• Flexibilidad para arquitecturas complejas (microservicios, reactive, etc.). 
• Amplio soporte en el mundo empresarial y open source.

Contras:

• Puede volverse pesado si no se gestiona bien la configuración. 
• Arranque más lento en comparación con ASP .Net Core. 
• Requiere atención a versiones y dependencias para evitar conflictos.

¿Qué herramienta elegir?

Debes considerar que ASP .Net Core usa C#, ideal si vienes del ecosistema Microsoft o te interesa trabajar con Windows, Azure, o videojuegos (Unity).

Spring Boot usa Java como lenguaje base (aunque puedes optar por Kotlin o Groovy), excelente si te atrae el desarrollo empresarial, Android, o sistemas robustos multiplataforma.

Spring Boot tiene una comunidad más grande globalmente, con muchos tutoriales, cursos y proyectos open source.

ASP .Net Core tiene fuerte soporte en empresas que usan Microsoft stack, especialmente en América Latina y EE.UU.

Java/Spring Boot suele tener más demanda en bancos, aseguradoras y grandes corporativos.

ASP .Net Core es común en consultoras, software a medida, y empresas que usan Azure.

ASP .Net Core tiene una curva más suave si usas Visual Studio y te gusta trabajar con herramientas integradas

Spring Boot puede ser más complejo al principio, pero te da más control y flexibilidad a largo plazo.

Veredicto final

.Net es una tecnología que cuenta con el respaldo de Microsoft y posee una compatibilidad con Azure de manera natural. Sin embargo, Java es el lenguaje más usado en entornos empresariales y eso otorga a Spring Boot cierta ventaja en el mercado laboral.

Si fueses un programador que necesita consolidarse y "agarrar un puesto" en el mundo de la tecnología web. Spring Boot sería el ideal.

Aunque ASP .Net Core ha ido robando terreno y le pisa los talones a otras herramientas como Spring Boot y podría dar la sorpresa de ganarle algunas áreas como el ámbito gubernamental. En el mundo del IT nada está escrito.

Enlaces:

https://dotnet.microsoft.com/es-es/apps/aspnet
https://www.arquitecturajava.com/spring-boot-que-es/
https://azure.microsoft.com/es-mx/resources/cloud-computing-dictionary/what-is-java-spring-boot
https://codemonkeyjunior.blogspot.com/2025/08/programando-en-c-no-9-usando-nuget.html
https://codemonkeyjunior.blogspot.com/2019/06/instalar-paquetes-nuget-con-dotnet.html
https://codemonkeyjunior.blogspot.com/2019/05/crear-una-aplicacion-web-con-asp-net.html

El roadmap para ser desarrollador C#

Nota: Este post esta basado en https://www.youtube.com/watch?v=sZVqGIW6Jno

Aquí un roadmap para ser desarrollador C#.

1. Aprender C# desde la consola.

• Aprende a usar la consola para crear proyectos, compilarlos y ejecutarlos. 
• Conoce el lenguaje, los paradigmas que usa. Los tipos de datos, estructuras de control (if, if-else, for, while, etc.) y estructuras de datos. 
• Entiende lo que es el paradigma orientado a objetos.
• Crea aplicaciones de consola para aprender y poner en práctica los fundamentos. 
• Crea aplicaciones para el manejo de archivos (abrir archivos, crearlos y borrarlos). 
• Crea aplicaciones para acceder a BD (el clásico CRUD). 
• Crea aplicaciones para acceder a API's públicas.

Nota: Olvídate de aprender Visual Basic .NET a menos que tengas que trabajar con código legado. También olvídate de las aplicaciones tipo ventana (Windows Forms) a menos que sea necesario. Y centrate solo en .NET y no en .NET Framework.

Domina lo básico antes de entrar al desarrollo web.

2. Aprender ASP .NET MVC

• Comprende el concepto de Modelo-Vista-Controlador. Aprende WepApi, Api Controllers, Routing, ViewModels y MVVM.
• No aprendas Razor Pages y/o Blazor (solo si no quieres aprender Javascript).
• Tampoco Net MAUI.

Si entiendes las bases del Modelo-Vista-Controlador estás listo para el siguiente paso.

3. Aprende HTML, CSS y Javascript (y Typescript)

• Como maquetar una página web, aprender las etiquetas HTML.
• Cómo darle estilo a una página web con CSS.
• Cómo crear eventos con Javascript, cómo usar funciones como fetch, etc.
• Aprende Typescript, un Javascript de tipado.
• Entender lo básico de Node JS.
• Aprende React JS (no empieces con Angular, ya que es más complejo).
• Crea una aplicación SPA.

Javascript es un mundo, así que siempre vas a encontrar algo nuevo por aprender. Typescript es su "sucesor".

4. Concéntrate en éstos conceptos

• Comprende lo que es la Inyección de dependencias (Dependency Injection).
• Entiende sobre código limpio. 
• Aprende sobre patrones de diseño y principio SOLID.
• Cómo crear pruebas unitarias (xUnit).
• Cómo usar logging (Serilog) en tus aplicaciones.

Si ya comprendes estos conceptos, estás listo para lo que sigue.

5. Aprender Sql Server

• No uses MySQL, Mongo, PostreSQL, etc. Antes aprende a usar Microsoft Sql Server. Como crear bases de datos, tablas, consultas, crear nuevos registros, actualizarlos y eliminarlos.
• Aprende a usar Entity Framework, el cual es un ORM similar a tecnologías como Hibernate.
• Aprende a usar LINQ (Language INtegrated Query), una librería que permite integrar capacidades de consulta de datos directamente en el lenguaje.

6. No te centres en cosas sin ningún valor

• No aprendas Web Forms y/o Windows Communication Foundation (WCF).

7. Crear aplicaciones MVC

• Crea una aplicación web.
• Aprende a usar Microsoft Azure (Azure app Service).

Ya estarás listo para crear servicios de mensajería con RabbitMQ o Apache Kafka y cosas más avanzadas. Podrías usar Github Copilot, ChatGPT u otra herramienta similar, pero no abuses de ella pues perderías el objetivo: aprender por ti mismo.

8. Docker y Kubernetes

• Aprende sobre contenedores con Docker. 
• Aprende a usar Kubernetes para administrar tus contenedores.

Enlaces:

https://roadmap.sh/aspnet-core
https://www.youtube.com/watch?v=sZVqGIW6Jno

Programando en C++ no.6: creando una simple calculadora

En esta ocasión crearemos una calculadora para obtener el IMC y pulsaciones de una persona.

1. El programa tendrá un menú con tres opciones (cálculo del IMC, cálculo de pulsaciones y salida). 
2. Tendrá un encabezado: calculo.hpp 
3. Un programa de implementación de ese encabezado: calculo.cpp 
4. Un programa main: main.cpp

El programa solicitará estos datos:

• nombre.
• peso.
• talla.
• edad. 
• género.

Definamos el encabezado. Recordemos que al ser C++ la extensión puede ser tanto *.h como *.hpp.

calculos.hpp

#ifndef CALCULOS_H
#define CALCULOS_H

#endif

En este archivo importaremos las librerías necesarias:

#ifndef CALCULOS_H
#define CALCULOS_H

#include <ctime>
#include <iostream>
#include <string>
#include <iomanip>
using namespace std;


#endif

También podemos definir "constantes" de esta forma:

#ifndef CALCULOS_H
#define CALCULOS_H

#define HOMBRE_PULS 220
#define MUJER_PULS 226
#define OPC_1 1
#define OPC_2 2

#include <ctime>
#include <iostream>
#include <string>
#include <iomanip>
using namespace std;


#endif

Dentro del encabezado crearemos una clase para contener lo datos solicitados:

#ifndef CALCULOS_H
#define CALCULOS_H

#define HOMBRE_PULS 220
#define MUJER_PULS 226
#define OPC_1 1
#define OPC_2 2

#include <ctime>
#include <iostream>
#include <string>
#include <iomanip>
using namespace std;


class Register
{
private:
    time_t hora_dia;
    string nombre;
    int edad;
    double talla;
    double peso;

public:
    Register() : hora_dia(time(nullptr)), nombre(""), edad(0), talla(0.0), peso(0.0) {}

    Register(const string &nombre_, int edad_, double talla_, double peso_)
        : hora_dia(time(nullptr)), nombre(nombre_), edad(edad_), talla(talla_), peso(peso_) {}

    time_t getHoraDia() const { return hora_dia; }
    string getNombre() const { return nombre; }
    int getEdad() const { return edad; }
    double getTalla() const { return talla; }
    double getPeso() const { return peso; }

    void setNombre(const string &nombre_) { nombre = nombre_; }
    void setEdad(int edad_) { edad = edad_; }
    void setTalla(double talla_) { talla = talla_; }
    void setPeso(double peso_) { peso = peso_; }
    void setHoraDia(time_t hora_) { hora_dia = hora_; }

    void mostrar() const
    {
        tm *tiempo_local = localtime(&hora_dia);
        cout << "Registro:" << endl;
        cout << "Nombre: " << nombre << endl;
        cout << "Edad: " << edad << " años" << endl;
        cout << "Talla: " << talla << " m" << endl;
        cout << "Peso: " << peso << " kg" << endl;
        cout << "Hora del día: " << put_time(tiempo_local, "%Y-%m-%d %H:%M:%S") << endl;
    }
};

#endif

Esta clase tiene los atributos de nombre, edad, talla, peso y definimos un campo de hora. Además de contar con sus setters y getters, y un método para mostrar todos los datos.

Definamos ahora los encabezados de las funciones para calcular el IMC, las pulsaciones, el menú, y la introducción de datos.

calculos.hpp

#ifndef CALCULOS_H
#define CALCULOS_H

#define HOMBRE_PULS 220
#define MUJER_PULS 226
#define OPC_1 1
#define OPC_2 2

#include <ctime>
#include <iostream>
#include <string>
#include <iomanip>
using namespace std;

class Register
{
private:
    time_t hora_dia;
    string nombre;
    int edad;
    double talla;
    double peso;

public:
    Register() : hora_dia(time(nullptr)), nombre(""), edad(0), talla(0.0), peso(0.0) {}

    Register(const string &nombre_, int edad_, double talla_, double peso_)
        : hora_dia(time(nullptr)), nombre(nombre_), edad(edad_), talla(talla_), peso(peso_) {}

    time_t getHoraDia() const { return hora_dia; }
    string getNombre() const { return nombre; }
    int getEdad() const { return edad; }
    double getTalla() const { return talla; }
    double getPeso() const { return peso; }

    void setNombre(const string &nombre_) { nombre = nombre_; }
    void setEdad(int edad_) { edad = edad_; }
    void setTalla(double talla_) { talla = talla_; }
    void setPeso(double peso_) { peso = peso_; }
    void setHoraDia(time_t hora_) { hora_dia = hora_; }

    void mostrar() const
    {
        tm *tiempo_local = localtime(&hora_dia);
        cout << "Registro:" << endl;
        cout << "Nombre: " << nombre << endl;
        cout << "Edad: " << edad << " años" << endl;
        cout << "Talla: " << talla << " m" << endl;
        cout << "Peso: " << peso << " kg" << endl;
        cout << "Hora del día: " << put_time(tiempo_local, "%Y-%m-%d %H:%M:%S") << endl;
    }
};

void limpiarPantalla(void);
void introduceDatos(void);
double getIMC(double peso, double talla);
double getPulsaciones(int edad);
void inicia(void);
int menu(void);
void obtenerCalcImc(Register r1);
void obtenerCalcPuls(Register r1);
std::string clasificarIMC(double imc);

#endif

Con esto terminamos el archivo de encabezados. Ahora continuaremos con el programa implementador.

calculos.cpp

#include "calculos.hpp"

En este importaremos el encabezado. Además de implementar cada una de las funciones declararas en el encabezado.

calculos.cpp

#include "calculos.hpp"

double getIMC(double peso, double talla)
{
    return peso / (talla * talla);
}

double getPulsaciones(int edad)
{
    if (OPC_1 == 1)
    {
        return HOMBRE_PULS - (0.7 * edad);
    }
    else if (OPC_2 == 2)
    {
        return MUJER_PULS - (0.8 * edad);
    }
    else
    {
        return 0.0;
    }
}

std::string clasificarIMC(double imc)
{
    std::string cad = "";

    if (imc < 16.00)
    {
        cad = "Infrapeso: Delgadez Severa";
    }
    else if (imc <= 16.99)
    {
        cad = "Infrapeso: Delgadez moderada";
    }
    else if (imc <= 18.49)
    {
        cad = "Infrapeso: Delgadez aceptable";
    }
    else if (imc <= 24.99)
    {
        cad = "Peso Normal";
    }
    else if (imc <= 29.99)
    {
        cad = "Sobrepeso";
    }
    else if (imc <= 34.99)
    {
        cad = "Obeso: Tipo I";
    }
    else if (imc <= 35.00 || imc == 40.00)
    {
        cad = "Obeso: Tipo III";
    }
    else
    {
        cad = "no existe clasificacion";
    }

    return cad;
}

void obtenerCalcImc(Register r1)
{
    double imc = getIMC(r1.getPeso(), r1.getTalla());
    r1.mostrar();
    cout << "El IMC es de " << imc << " kg/(m*m)" << endl;
    cout << "Diagnostico: " << clasificarIMC(imc) << endl;
}

void limpiarPantalla() {
#ifdef _WIN32
    system("cls");
#else
    system("clear");
#endif
}


void obtenerCalcPuls(Register r1)
{   r1.mostrar();
    cout << "El no. de pulsaciones es de " << getPulsaciones(r1.getEdad()) << " por minuto." << endl;
}

int menu()
{
    int opc;
    cout << "\t *******  MENU ******" << endl;
    cout << "\t 1. Obtener IMC." << endl;
    cout << "\t 2. Obtener pulsaciones." << endl;
    cout << "\t 3. Salir." << endl;
    do
    {
        cout << "Introduce opcion:" << endl;
        cin >> opc;
    } while (opc < 0 || opc > 3);
    return opc;
}


string nombre;
double peso, talla;
int edad, genero;
Register r1;
void introduceDatos()
{
    cout << "\t *********************************" << endl;
    cout << "Introduce nombre de la persona: " << endl;
    cin >> nombre;
    cout << "Introduce talla: " << endl;
    cin >> talla;
    cout << "Introduce peso: " << endl;
    cin >> peso;
    cout << "Introduce edad: " << endl;
    cin >> edad;
    cout << "Introduce tu genero [Masculino: 1,  Femenino: 2]:" << endl;
    cin >> genero;
    cout << "\t *********************************" << endl;
    r1.setNombre(nombre);
    r1.setEdad(edad);
    r1.setTalla(talla);
    r1.setPeso(peso);
}

void inicia(void)
{
    limpiarPantalla();
    int opcion = 0; 
    for (;;)
    {
        opcion = menu();
        cout << "Tu opcion fue: " << opcion << endl;
        switch (opcion)
        {
        case 1:
            introduceDatos();
            obtenerCalcImc(r1);
            break;
        case 2:
            introduceDatos();
            obtenerCalcPuls(r1);
            break;
        case 3:
            exit(0);
            break;
        }
    }
}

¿Qué podemos ver en este archivo?

• Hemos implementado cada una de las funciones declaradas en el encabezado.
• Estas funciones comprenden el menú del programa.
• La introducción de opciones a elegir y datos del usuario.
• El cálculo de cada operación y el resultado.

Miremos ahora el programa main:

main.cpp

#include "calculos.cpp"

int main(int argc, char const *argv[])
{
    inicia();
    return 0;
}

Este solo hace una importación del archivo implementador (calculos.cpp) e invoca la función que dispara la ejecución del programa (función inicia).

¿Qué sigue?

Compilamos:

$ g++ main.cpp -o calculadora.exe

Ejecutamos:

$ calculadora.exe

Salida:

         *******  MENU ******
         1. Obtener IMC.
         2. Obtener pulsaciones.
         3. Salir.
Introduce opcion:
1
Tu opcion fue: 1
         *********************************
Introduce nombre de la persona:
THOMAS
Introduce talla:
1.78
Introduce peso:
73
Introduce edad:
44
Introduce tu genero [Masculino: 1,  Femenino: 2]:
1
         *********************************
Registro:
Nombre: THOMAS
Edad: 44 a├▒os
Talla: 1.78 m
Peso: 73 kg
Hora del día: 2025-10-25 13:05:05
El IMC es de 23.04 kg/(m*m)
Diagnostico: Peso Normal
         *******  MENU ******
         1. Obtener IMC.
         2. Obtener pulsaciones.
         3. Salir.

Si elegimos la opción 2:

         *******  MENU ******
         1. Obtener IMC.
         2. Obtener pulsaciones.
         3. Salir.
Introduce opcion:
2
Tu opcion fue: 2
         *********************************
Introduce nombre de la persona:
MARIA
Introduce talla:
1.66
Introduce peso:
65
Introduce edad:
32
Introduce tu genero [Masculino: 1,  Femenino: 2]:
2
         *********************************
Registro:
Nombre: MARIA
Edad: 32 a├▒os
Talla: 1.66 m
Peso: 65 kg
Hora del día: 2025-10-25 13:06:30
El no. de pulsaciones es de 197.6 por minuto.
         *******  MENU ******
         1. Obtener IMC.
         2. Obtener pulsaciones.
         3. Salir.

¿Qué hemos visto?

• Como crear un programa en C++ mediante "módulos". 
• Como crear clases e instanciar objetos de esa clase. 
• Como crear archivos encabezados (calculos.hpp). 
• Como implementar las funciones definidas en ese archivo de encabezados (calculos.cpp). 
• Como invocar funciones que disparen una acción desde un programa main (main.cpp).

Enlaces:

https://codemonkeyjunior.blogspot.com/2025/10/creando-una-aplicacion-web-sencilla-con.html
https://codemonkeyjunior.blogspot.com/2024/06/hace-tiempo-vimos-como-crear-un.html

Consumiendo una API pública con Kotlin & OkHttp

En el pasado post vimos cómo consumir un servicio Node desde una aplicación Java gracias a la librería OkHttp. Esta vez usaremos Kotlin como lenguaje base y Gradle para la administración de las dependencias y ejecución del proyecto.

¿Qué haremos?

• Crear una aplicación Kotlin con Gradle. 
• Consumir una API pública: https://api.chucknorris.io/jokes/random

1. Comenzaremos con la creación del directorio del proyecto:

$ mkdir proyecto-kotlin
$ cd proyecto-kotlin

El directorio del proyecto se verá así:

proyecto-kotlin/
   .gitattributes
   .gitignore
   .gradle
   .kotlin
   app/
   build/
   gradle/
   gradle.properties
   gradlew
   gradlew.bat
   settings.gradle.kts

2. Agregamos la dependencia de ``OkHttp`` en el archivo ``build.gradle.kts``:

plugins {
    alias(libs.plugins.kotlin.jvm)
    application
}

repositories {
    mavenCentral()
}

dependencies {
    implementation("com.squareup.okhttp3:okhttp:4.12.0") // Moved to implementation
    testImplementation("org.jetbrains.kotlin:kotlin-test")
    testImplementation(libs.junit.jupiter.engine)
    testRuntimeOnly("org.junit.platform:junit-platform-launcher")
    implementation(libs.guava)
    testImplementation("org.junit.jupiter:junit-jupiter:5.10.3")
    testImplementation("org.mockito:mockito-core:5.12.0")
    testImplementation("org.mockito:mockito-junit-jupiter:5.12.0")
}

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(21)
    }
}

application {
    mainClass = "org.inforhomex.AppKt"
}

tasks.named<Test>("test") {
    useJUnitPlatform()
}

Con esto se podrá descargar la dependencia.

3. Editamos el programa ``app/src/main/kotlin/org/inforhomex/App.kt``.

package org.inforhomex

import okhttp3.OkHttpClient
import okhttp3.Request
import java.io.IOException

private const val URL_API = "https://api.chucknorris.io/jokes/random"

fun run(client: OkHttpClient = OkHttpClient()) {
    val request = Request.Builder().url(URL_API).build()
    client.newCall(request).execute().use { response ->
        if (!response.isSuccessful) throw IOException("Unexpected code $response")
        for ((name: String, value: String) in response.headers) {
            println("$name: $value")
        }
        println(response.body?.string() ?: "No response body")
    }
}

fun main() {
    run()
}

4. Creamos una prueba unitaria ``AppTest.kt``

package org.inforhomex


import okhttp3.*
import okio.Buffer
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.extension.ExtendWith
import org.mockito.Mock
import org.mockito.Mockito
import org.mockito.junit.jupiter.MockitoExtension
import java.io.IOException
import kotlin.test.assertEquals
import kotlin.test.assertFailsWith

@ExtendWith(MockitoExtension::class)
class AppTest {

    @Mock
    private lateinit var client: OkHttpClient

    @Mock
    private lateinit var response: Response

    @Mock
    private lateinit var responseBody: ResponseBody

    @Mock
    private lateinit var call: Call

    private val urlApi = "https://api.chucknorris.io/jokes/random"

    @BeforeEach
    fun setUp() {
        
        Mockito.`when`(client.newCall(Mockito.any(Request::class.java))).thenReturn(call)
    }

    @Test
    fun `test run success response`() {
        
        val mockJson = """
            {
                "icon_url": "https://assets.chucknorris.host/img/avatar/chuck-norris.png",
                "id": "abc123",
                "url": "",
                "value": "Chuck Norris can divide by zero."
            }
        """
        Mockito.`when`(call.execute()).thenReturn(response)
        Mockito.`when`(response.isSuccessful).thenReturn(true)
        Mockito.`when`(response.body).thenReturn(responseBody)
        Mockito.`when`(responseBody.string()).thenReturn(mockJson)
        Mockito.`when`(response.headers).thenReturn(Headers.Builder().add("Content-Type", "application/json").build())

        
        val output = captureOutput {
            run(client) 
        }

        
        assert(output.contains("Content-Type: application/json"))
        assert(output.contains("Chuck Norris can divide by zero."))
    }

    @Test
    fun `test run unsuccessful response throws IOException`() {
       
        Mockito.`when`(call.execute()).thenReturn(response)
        Mockito.`when`(response.isSuccessful).thenReturn(false)
        Mockito.`when`(response.code).thenReturn(404)

       
        val exception = assertFailsWith<IOException> {
            run(client) 
        }
        assertEquals("Unexpected code 404", exception.message)
    }

    
    private fun captureOutput(block: () -> Unit): String {
        val outputStream = java.io.ByteArrayOutputStream()
        val printStream = java.io.PrintStream(outputStream)
        val originalOut = System.out
        System.setOut(printStream)
        try {
            block()
        } finally {
            System.setOut(originalOut)
        }
        return outputStream.toString()
    }
}

5. Compilamos y ejecutamos la aplicación:

$ gradle build
$ gradle run

Si todo va bien, veremos esto en la consola:

date: Sun, 19 Oct 2025 03:25:17 GMT
content-type: application/json
nel: {"report_to":"heroku-nel","response_headers":["Via"],"max_age":3600,"success_fraction":0.01,"failure_fraction":0.1}
report-to: {"group":"heroku-nel","endpoints":[{"url":"https://nel.heroku.com/reports?s=e%2BRTonTfjrgED0WXfh1o2mxbl6%2BLhQQ4LIu%2F1NhF4MM%3D\u0026sid=812dcc77-0bd0-43b1-a5f1-b25750382959\u0026ts=1760844317"}],"max_age":3600}
reporting-endpoints: heroku-nel="https://nel.heroku.com/reports?s=e%2BRTonTfjrgED0WXfh1o2mxbl6%2BLhQQ4LIu%2F1NhF4MM%3D&sid=812dcc77-0bd0-43b1-a5f1-b25750382959&ts=1760844317"
server: cloudflare
vary: Origin
vary: Access-Control-Request-Method
vary: Access-Control-Request-Headers
via: 1.1 heroku-router
cf-cache-status: DYNAMIC
cf-ray: 990d2ad69c2f69de-DFW
alt-svc: h3=":443"; ma=86400
{"categories":[],"created_at":"2020-01-05 13:42:20.262289","icon_url":"https://api.chucknorris.io/img/avatar/chuck-norris.png","id":"zDUih4UaS82sDRjSX0hlLQ","updated_at":"2020-01-05 13:42:20.262289","url":"https://api.chucknorris.io/jokes/zDUih4UaS82sDRjSX0hlLQ","value":"Chuck Norris always wanted to surf but couldn't. Everytime his board touches the water, the sea parts."}

¡La aplicación ha funcionado correctamente!

Continuaremos con esta serie de ejemplos en próximas entregas.

Enlaces:

https://square.github.io/okhttp/
https://www.baeldung.com/guide-to-okhttp
https://ironpdf.com/es/java/blog/java-help/okhttp-java/