DEV Community: Roger Viñas Alcon

Spring Boot AI Evaluation Testing

Roger Viñas Alcon — Tue, 22 Apr 2025 07:26:28 +0000

In this example, inspired by Building Agents with AWS: Complete Tutorial, we will build a simple AI agent application using Spring AI, highlighting key features like:

Chat Client API and its Advisors
Model Context Protocol (MCP)
Retrieval Augmented Generation (RAG)
Testing with AI Model Evaluation 🤩

The original example uses AWS Bedrock, but one of the great things about Spring AI is that with just a few config tweaks, the same code works with any other supported model. This project supports three profiles: Ollama (local), Google Gemini and AWS Bedrock.

The application features an AI agent that helps users book accommodations in tourist destinations.

Through MCP, the agent can use the following tools:

Weather Tool: Retrieves weather information for a specific city and date.
Booking Tool: Books accommodations in a city for a specific date.

The Weather tool will be implemented locally using MCP, while the Booking tool will be provided by a remote MCP server. The current date is provided via the system prompt. Additional information about cities will be retrieved from a vector store using RAG.

Implementation
- MCP Server
- Chat Server
  - Components
    - Weather Tool
    - Booking Tool
    - Chat Client
    - Chat Service
    - Chat Controller
    - Vector Store Initializer
Configuration
- Ollama profile
- Gemini profile
- Bedrock profile
Test
- Test MCP Server
- Test Chat Server
Run
- Running the vector database
- Running Ollama locally
- Running the application
How to use other AI models
Documentation

Implementation

MCP Server

As is often the case with Spring Boot, implementing the MCP Server is pretty straightforward. Following the MCP Server Boot Starter guide, you just need to:

1) Add the spring-ai-starter-mcp-server-webflux or spring-ai-starter-mcp-server-webmvc dependency

2) Create an instance and annotate it with @Tool and @ToolParam:

@Service // or @Bean / @Component
class BookingTool(private val bookingService: BookingService) {
  @Tool(
    description = "make a reservation for accommodation for a given city and date",
  )
  fun book(
    @ToolParam(description = "the city to make the reservation for")
    city: String,
    @ToolParam(description = "the check-in date, when the reservation begins")
    checkinDate: LocalDate,
    @ToolParam(description = "the check-out date, when the reservation ends")
    checkoutDate: LocalDate
  ): String = bookingService.book(city, checkinDate, checkoutDate) // Delegate to a service
}

3) Register it as a MethodToolCallbackProvider:

@Configuration
class BookingToolConfiguration {
  @Bean
  fun bookingToolCallbackProvider(bookingTool: BookingTool) = 
    MethodToolCallbackProvider.builder()
      .toolObjects(bookingTool)
      .build()
}

Chat Server

The Chat Server is a Spring Boot application built with the following dependencies:

spring-boot-starter-web or -webflux - to expose a REST API for the chat interface
spring-ai-starter-mcp-client - to use MCP
spring-ai-starter-vector-store-pgvector and spring-ai-advisors-vector-store - to enable RAG with PGVector
spring-ai-starter-model-ollama - to use Ollama models
spring-ai-starter-model-google-genai and spring-ai-starter-model-google-genai-embedding - to use Google Gemini models
spring-ai-starter-model-bedrock and spring-ai-starter-model-bedrock-converse - to use AWS Bedrock models

Components

MCP Tools
- Weather Tool - a local MCP tool that queries a WeatherService for the weather in a given city on a given date
- Booking Tool - a remote MCP tool that connects to the Booking MCP Server to reserve accommodations
Chat
- Chat Client - a Spring AI ChatClient configured with:
  - A system prompt to define the AI agent’s role and the current date
  - The AI model autoconfigured by Spring Boot via the active profile
  - The above MCP tools as part of the AI agent’s toolset
- Chat Service - wraps the Chat Client and adds three advisors:
  - QuestionAnswerAdvisor - fetches context from a vector store and augments the user input (RAG)
  - PromptChatMemoryAdvisor - adds conversation history to the user input (chat memory)
  - SimpleLoggerAdvisor - logs the chat history to the console (for debugging)
- Chat Controller - exposes a simple REST POST endpoint that takes user input, calls the Chat Service, and returns the AI agent’s response
Vector Store Initializer - loads some sample data into the vector store at startup

Let's implement this step by step ...

Weather Tool

Here's how the Weather Tool is implemented:

1) Create an instance and annotate it with @Tool and @ToolParam:

@Service // or @Bean / @Component
class WeatherTool(private val weatherService: WeatherService) {
  @Tool(description = "get the weather for a given city and date")
  fun getWeather(
    @ToolParam(description = "the city to get the weather for")
    city: String,
    @ToolParam(description = "the date to get the weather for") 
    date: LocalDate
  ): String = weatherService.getWeather(city, date) // Delegate to a service
}

2) Register it as a MethodToolCallbackProvider:

@Configuration
class WeatherToolConfiguration {
  @Bean
  fun weatherToolCallbackProvider(weatherTool: WeatherTool) =
    MethodToolCallbackProvider.builder()
      .toolObjects(weatherTool)
      .build()
}

Booking Tool

To set up the Booking Tool as a remote MCP tool, we just need to configure the MCP client SSE connection in application.properties:

spring.ai.mcp.client.toolcallback.enabled=true
spring.ai.mcp.client.sse.connections.booking-tool.url=http://localhost:8081

You can find all the alternative configurations in MCP Client Boot Starter documentation.

Chat Client

We create the Chat Client using Spring AI's ChatClient.Builder, which is already autoconfigured via spring.ai configuration properties (we'll talk at that later in Configuration), and initialize it with a custom system prompt and the available MCP tools:

@Configuration
class ChatClientConfiguration {
  @Bean
  fun chatClient(
    builder: ChatClient.Builder,
    toolCallbackProviders: List<ToolCallbackProvider>
  ): ChatClient {
    return chatClientBuilder(builder, toolCallbackProviders).build()
  }

  private fun chatClientBuilder(
    builder: ChatClient.Builder,
    toolCallbackProviders: List<ToolCallbackProvider>
  ): ChatClient.Builder {
    val system = """
      You are an AI powered assistant to help people book accommodation in touristic cities around the world.
      If there is no information, then return a polite response suggesting you don't know.
      If the response involves a timestamp, be sure to convert it to something human-readable.
      Do not include any indication of what you're thinking.
      Use the tools available to you to answer the questions.
      Just give the answer.
      When booking accommodation for a weekend, assume check-in on Saturday and check-out on Monday.
      Current date: {currentDate}
      """.trimIndent()
    return builder
      .defaultSystem(system)
      .defaultToolCallbacks(*toolCallbackProviders.toTypedArray())
  }
}

Chat Service

The Chat Service exposes a single chat method that takes a chat ID and a user question. It calls the Chat Client with the user question along with a set of advisors to enrich the interaction:

QuestionAnswerAdvisor - retrieves relevant context from a vector store and injects it to the context (RAG)
PromptChatMemoryAdvisor - retrieves or creates an InMemoryChatMemoryRepository for the given chat ID and adds it to the context
SimpleLoggerAdvisor - logs internal advisor traces to the console (if logging.level.org.springframework.ai.chat.client.advisor is set to DEBUG)

Additionally, the question and answer are logged to the console.

Here’s the implementation:

@Service // or @Bean / @Component
class ChatService(
  vectorStore: VectorStore,
  private val clock: Clock,
  private val chatClient: ChatClient
) {
  private val logger = LoggerFactory.getLogger(ChatService::class.java)
  private val questionAnswerAdvisor = QuestionAnswerAdvisor.builder(vectorStore).build()
  private val simpleLoggerAdvisor = SimpleLoggerAdvisor()
  private val chatMemory = ConcurrentHashMap<String, PromptChatMemoryAdvisor>()

  fun chat(chatId: String, question: String): String {
    val chatMemoryAdvisor = chatMemory.computeIfAbsent(chatId) {
      PromptChatMemoryAdvisor.builder(
        MessageWindowChatMemory.builder()
          .chatMemoryRepository(InMemoryChatMemoryRepository())
          .build()
      ).build()
    }
    return chatClient
      .prompt()
      .system { it.param("currentDate", LocalDate.now(clock)) }
      .user(question)
      .advisors(questionAnswerAdvisor, chatMemoryAdvisor, simpleLoggerAdvisor)
      .call()
      .content().apply {
        logger.info("Chat #$chatId question: $question")
        logger.info("Chat #$chatId answer: $this")
      }!!
  }
}

Chat Controller

The Chat Controller exposes a simple REST POST endpoint that takes user input, calls the Chat Service, and returns the AI agent’s response:

@RestController
class ChatController(private val chatService: ChatService) {
  @PostMapping("/{chatId}/chat")
  fun chat(
    @PathVariable chatId: String, 
    @RequestParam question: String
  ): String? {
    return chatService.chat(chatId, question)
  }
}

Vector Store Initializer

It's as simple as using Spring AI’s autoconfigured VectorStore and adding documents to it. This automatically invokes the embedding model to generate embeddings and store them in the vector store:

@Bean
fun vectorStoreInitializer(vectorStore: VectorStore) = 
  ApplicationRunner {
    // TODO check if the vector store is empty ...
    // TODO load cities from a JSON file or any other source ...
    cities.forEach { city ->
      val document = Document(
        "name: ${city.name} " +
        "country: ${city.country} " +
        "description: ${city.description}"
      )
      vectorStore.add(listOf(document))
    }
  }

You can find the full version of vectorStoreInitializer in ChatServerApplication.kt.

Configuration

We use application.properties instead of application.yml because YAML cannot have both spring.ai.model.embedding (scalar, used by Bedrock and Ollama) and spring.ai.model.embedding.text (nested, used by Gemini) at the same time. Maybe some day this will be solved, but anyway this is a PoC that supports multiple models — in a production application you'd likely use only one, so this wouldn't be an issue.

In this file, we define global configuration values:

Disable all model auto-configurations by default.
Configure the datasource to connect to a PostgreSQL database with PGVector support.
Set the server port to 8080.
Configure the URL of the remote Booking Tool MCP server.
Set the logging level for chat advisor debug traces.

spring.application.name=chat-server

spring.datasource.url=jdbc:postgresql://localhost:5432/postgres
spring.datasource.username=postgres
spring.datasource.password=password
spring.datasource.driver-class-name=org.postgresql.Driver

spring.ai.model.chat=none
spring.ai.model.embedding=none
spring.ai.model.embedding.text=none

spring.ai.mcp.client.toolcallback.enabled=true
spring.ai.mcp.client.sse.connections.booking-tool.url=http://localhost:8081

server.port=8080

logging.level.org.springframework.ai.chat.client.advisor=INFO

The AI model is configured via Spring profiles. Each profile sets the chat model, embedding model, and vector store dimensions. The active profile must be specified at runtime using SPRING_PROFILES_ACTIVE.

Ollama profile

In application-ollama.yml, we configure Spring AI to use Ollama models:

Set the base URL for the Ollama server to http://localhost:11434.
Set the chat model to llama3.1:8b (must be a tools-enabled model).
Set the embedding model to nomic-embed-text.
Use pull-model-strategy: when_missing to only pull models if they are not available locally.
Configure PGVector as the vector store with 768 dimensions (matching the embedding model size).

spring:
  ai:
    model:
      embedding: "ollama"
      chat: "ollama"
    ollama:
      base-url: "http://localhost:11434"
      init:
        pull-model-strategy: "when_missing"
      chat:
        options:
          model: "llama3.1:8b"
      embedding:
        options:
          model: "nomic-embed-text"
    vectorstore:
      pgvector:
        table-name: "vector_store_ollama"
        dimensions: 768
        initialize-schema: true

Gemini profile

In application-gemini.yml, we configure Spring AI to use Google Gemini models:

Set the Google API key from the GOOGLE_API_KEY environment variable.
Set the chat model to gemini-2.5-flash.
Set the embedding model to gemini-embedding-001 with 768 dimensions.
Configure PGVector as the vector store with 768 dimensions.

spring:
  ai:
    model:
      chat: "google-genai"
      embedding:
        text: "google-genai"
    google:
      genai:
        api-key: "${GOOGLE_API_KEY}"
        chat:
          options:
            model: "gemini-2.5-flash"
            temperature: 0.7
        embedding:
          api-key: "${GOOGLE_API_KEY}"
          text:
            options:
              model: "gemini-embedding-001"
              dimensions: 768
    vectorstore:
      pgvector:
        table-name: "vector_store_gemini"
        dimensions: 768
        initialize-schema: true

Bedrock profile

In application-bedrock.yml, we configure Spring AI to use AWS Bedrock models:

Set the AWS credentials and region from environment variables.
Set the chat model using Bedrock Converse API.
Set the embedding model using Bedrock Cohere.
Configure PGVector as the vector store with 1024 dimensions (matching the Cohere embedding model size).

spring:
  ai:
    model:
      embedding: "bedrock-cohere"
      chat: "bedrock-converse"
    bedrock:
      aws:
        access-key: "${AWS_ACCESS_KEY_ID}"
        secret-key: "${AWS_SECRET_ACCESS_KEY}"
        region: "${AWS_REGION:eu-central-1}"
      converse:
        chat:
          options:
            model: "${AWS_BEDROCK_CHAT_MODEL}"
            max-tokens: 2048
      cohere:
        embedding:
          model: "${AWS_BEDROCK_EMBEDDING_MODEL}"
    vectorstore:
      pgvector:
        table-name: "vector_store_bedrock"
        dimensions: 1024
        initialize-schema: true

Test

Test MCP Server

To test the MCP Server, we will use a McpClient to call the book method of the Booking Tool, mocking the downstream BookingService:

See the simplified test implementation below. For the complete implementation, including a test that verifies the list of available tools, refer to McpServerApplicationTest.kt.

@SpringBootTest(webEnvironment = RANDOM_PORT)
class McpServerApplicationTest {

  // 1. Inject the server port (it is random)
  @LocalServerPort
  val port: Int = 0

  // 2. Mock the BookingService instance
  @MockitoBean
  lateinit var bookingService: BookingService

  @Test
  fun `should book`() {
    // 3. Create a McpClient connected to the server
    val client = McpClient.sync(
      HttpClientSseClientTransport("http://localhost:$port")
    ).build()
    client.initialize()
    client.ping()

    // 4. Mock the bookingService using argument captors
    val bookResult = "Booking is done!"
    val cityCaptor = argumentCaptor<String>()
    val checkinDateCaptor = argumentCaptor<LocalDate>()
    val checkoutDateCaptor = argumentCaptor<LocalDate>()
    doReturn(bookResult)
      .whenever(bookingService)
      .book(
        cityCaptor.capture(),
        checkinDateCaptor.capture(),
        checkoutDateCaptor.capture()
      )

    // 5. Call the tool
    val city = "Barcelona"
    val checkinDate = LocalDate.parse("2025-04-15")
    val checkoutDate = LocalDate.parse("2025-04-18")
    val result = client.callTool(CallToolRequest(
      "book",
      mapOf(
        "city" to city,
        "checkinDate" to checkinDate.toEpochDay(),
        "checkoutDate" to checkoutDate.toEpochDay()
      )
    ))

    // 6. Verify the result
    assertThat(result.isError).isFalse()
    assertThat(result.content).singleElement()
      .isInstanceOfSatisfying(TextContent::class.java) {
        // TODO why is text double quoted?
        assertThat(it.text).isEqualTo("\"$bookResult\"")
      }

    // 7. Verify that the bookingService was called with
    // the correct parameters
    assertThat(cityCaptor.allValues).singleElement()
      .isEqualTo(city)
    assertThat(checkinDateCaptor.allValues).singleElement()
      .isEqualTo(checkinDate)
    assertThat(checkoutDateCaptor.allValues).singleElement()
      .isEqualTo(checkoutDate)

    // 8. Close the client
    client.close()
  }
}

Test Chat Server

To test the Chat Server, we will:

Override the default profile to gemini and disable the MCP client in application-test.yml (overridable via SPRING_PROFILES_ACTIVE).
Replace the remote Booking Tool by a local Booking Test Tool with the same signature.
- Create the local Book Testing Tool in BookingTestToolConfiguration.kt.
Mock the downstream services Weather Service and Booking Service with MockitoBean.
Create a fixed Clock to control the current date in ClockTestToolConfiguration.kt
- Declare it as @Primary @Bean to override the default Clock bean.
Start Docker Compose with PGVector using Testcontainers

You might’ve noticed that the test doesn’t actually check the MCP client’s SSE connection as it is disabled. I tried spinning up an McpServer using McpServerAutoConfiguration, and it almost worked. The problem? The client tries to connect before the server is up, which causes the whole application to fail on startup. Maybe is just an ordering issue, and hopefully something that can be fixed in the future 🤞

Now for the interesting part, how do we test the AI agent’s response? This is where Evaluation Testing comes in:

One method to evaluate the response is to use the AI model itself for evaluation. Select the best AI model for the evaluation, which may not be the same model used to generate the response.

This aligns with the evaluation techniques described in Martin Fowler’s Evals GenAI pattern:

Self-evaluation: The LLM evaluates its own response, but this can reinforce its own mistakes or biases.
LLM as a judge: Another model scores the output, reducing bias by introducing a second opinion.
Human evaluation: People manually review responses to ensure the tone and intent feel right.

To keep things simple, we’ll go with self-evaluation 🤓

Each test will follow this structure:

@Test
fun `should do something`() {
  // 1. Mock downstream service(s)
  // Optionally use argument captors depending on how you plan
  // to verify parameters in step 5
  // Example for BookingService:
  doReturn("Your booking is done!")
    .whenever(bookingTestService).book(any(), any(), any())

  // 2. Call the chat service
  val chatId = UUID.randomUUID().toString()
  val chatResponse = chatService.chat(
    chatId, 
    "Can you book accommodation for Barcelona from 2025-04-15 to 2025-04-18?"
  )

  // 3. Evaluate the response using the AI model
  val evaluationResult = TestEvaluator(chatClientBuilder) { evaluationRequest, userSpec ->
    userSpec.text(
      """
      Your task is to evaluate if the answer given by an AI agent to a human user matches the claim.
      Return YES if the answer matches the claim and NO if it does not.
      After returning YES or NO, explain why.
      Assume that today is ${LocalDate.now(clock)}.
      Answer: {answer}
      Claim: {claim}
      """.trimIndent()
    )
      .param("answer", evaluationRequest.responseContent)
      .param("claim", evaluationRequest.userText)
  }.evaluate(EvaluationRequest(
    "Accommodation has been booked Barcelona from 2025-04-15 to 2025-04-18", 
    chatResponse
  ))

  // 4. Assert the evaluation result is successful, show feedback if not
  assertThat(evaluationResult.isPass).isTrue
    .withFailMessage { evaluationResult.feedback }

  // 5. If applicable, verify the parameters passed to the service
  // You can verify with argument captors or use the `verify` method as in the example below:
  verify(bookingTestService).book(
    eq("Barcelona"), 
    eq(LocalDate.parse("2025-04-15")), 
    eq(LocalDate.parse("2025-04-18"))
  )
}

See the full test implementation in ChatServerApplicationTest.kt.

Each evaluation uses a custom prompt tailored to the specific response being tested, and as you experiment, you'll notice some surprisingly quirky behavior. That’s why I ended up creating a custom TestEvaluator, based on Spring AI’s RelevancyEvaluator and FactCheckingEvaluator, which may not yet offer the level of customization you might want.

I had to adjust each prompt after running into odd results. For example, the evaluation model assuming it was still 2023 and refusing to believe the AI agent could predict weather for 2025. Or it mistaking "you" in the answer as referring to itself instead of the user. The weirdest? One evaluation just answered “NO” but the explanation said, “well, maybe I should have said YES” 🤣

For a production system, you'd definitely need a lot of prompt tuning and testing to get things right, for both the system and the evaluator, I suppose that’s part of the "fun" when working with GenAI.

By default, tests use the Gemini profile both locally and in CI. You can also test with Ollama (results may be flaky without adequate GPU hardware) or Bedrock.

Run

You can configure the application using environment variables or a system.properties file in the root directory. This file is ignored by Git and is loaded by both ./gradlew bootRun and tests.

Example system.properties:

# AWS Bedrock
AWS_ACCESS_KEY_ID=...
AWS_SECRET_ACCESS_KEY=...
AWS_REGION=eu-central-1
AWS_BEDROCK_CHAT_MODEL=...
AWS_BEDROCK_EMBEDDING_MODEL=...

# Google Gemini
GOOGLE_API_KEY=...

Running the vector database

All profiles require PGVector for the RAG vector database:

cd chat-server
docker compose -f docker-compose-vectordb.yml up -d

To stop it:

cd chat-server
docker compose -f docker-compose-vectordb.yml down

To stop it and remove all volumes (removes all vector database data):

cd chat-server
docker compose -f docker-compose-vectordb.yml down -v

Running Ollama locally

If you want to use local LLMs, you can run Ollama either via Docker Compose or as a native application (more info at ollama.com).

cd chat-server
docker compose -f docker-compose-ollama.yml up -d

Running the application

1) Start MCP server

cd mcp-server
./gradlew bootRun

2) Start Chat Server with one of the following profiles:

Ollama (requires Ollama and vector database):

cd chat-server
SPRING_PROFILES_ACTIVE=ollama ./gradlew bootRun

Gemini (requires vector database and GOOGLE_API_KEY):

cd chat-server
SPRING_PROFILES_ACTIVE=gemini ./gradlew bootRun

Bedrock (requires vector database and AWS credentials):

cd chat-server
SPRING_PROFILES_ACTIVE=bedrock ./gradlew bootRun

3) Start chatting

A simple chat UI is available at http://localhost:8080/chat.html (disclaimer: this UI was entirely AI-generated as frontend is not the goal of this PoC).

You can also explore the API endpoints at http://localhost:8080/swagger-ui.html.

How to use other AI models

To use any of the other AI models supported by Spring AI, follow these steps:

Add the required dependencies
Configure the model in its own application-<model>.yml file
Activate the profile using SPRING_PROFILES_ACTIVE=<model>

Documentation

Spring AI documentation
Martin Fowler's GenAI patterns
Inspired by sample project spring-ai-java-bedrock-mcp-rag
Awesome Spring AI

Happy GenAI coding! 💙

Tests Everywhere - Swift

Roger Viñas Alcon — Mon, 18 Dec 2023 10:32:24 +0000

rogervinas / tests-everywhere

🤠 Tests, Tests Everywhere!

Swift testing this simple Hello World with XCTest and Cuckoo

Show me the code
- Implementation
- Test
Run this project using 🐳 docker
Run this project locally

Show me the code

Implementation

Sorry but reading that constant and variable names can contain almost any character, including Unicode characters I could not resist 😅 ...

1) Create HelloMessage class in HelloMessage.swift:

class HelloMessage {
  var 👋: String {
    get {
      return "Hello World!"
    }
  }
}

2) Same way create HelloConsole class in HelloConsole.swift:

class HelloConsole {
  func print(👋: String) {
    Swift.print(👋)
  }
}

3) Create HelloApp class in HelloApp.swift:

class HelloApp {

  let message: HelloMessage
  let console: HelloConsole

  init(message: HelloMessage, console: HelloConsole) {
    self.message = message
    self.console = console
  }

  func printHello() {
    console.print(👋: message.👋)
  }
}

4) Create main class in Main.swift that wraps it all together:

@main
public struct Main {
  public static func main() {
    let message = HelloMessage()
    let console = HelloConsole()
    let app = HelloApp(message: message, console: console)
    app.printHello()
  }
}

Test

Following XCTest and Cuckoo guides ...

1) Mock generation

Mocks have to be generated statically, you can follow these instructions or alternatively:

Build generator (only once, XCode command line tools required):

git clone git@github.com:Brightify/Cuckoo.git /tmp/Cuckoo
/tmp/Cuckoo/build_generator

Generate mocks (as many times as needed):

/tmp/Cuckoo/Generator/bin/cuckoo_generator generate \
  --testable Hello \
  --output Tests/Mocks.swift \
  Sources/HelloMessage.swift \
  Sources/HelloConsole.swift

You can also integrate mocks generation in the build, before compile phase.

2) Test HelloMessage in HelloMessageTest.swift:

final class HelloMessageTest: XCTestCase {
  func testHelloMessageShouldReturnHelloWorld() throws {
    let message = HelloMessage()
    XCTAssertEqual(message.👋, "Hello World!")
  }
}

3) Test HelloApp in HelloAppTest.swift:

final class HelloAppTest: XCTestCase {
  func testHelloAppShouldDisplayHelloMessage() throws {
    let messageText = "Hello Test!"
    // 2.1 Create a mock of HelloMessage
    let message = MockHelloMessage()
    // 2.2 Return "Hello Test!" whenever 👋 getter is called
    stub(message) { stub in
      when(stub.👋.get).thenReturn(messageText)
    }

    // 2.2 Create a mock of HelloConsole
    let console = MockHelloConsole()
    // 2.3 Do nothing whenever print is called
    stub(console) { stub in
      when(stub.print(👋: anyString())).thenDoNothing()
    }

    // 2.4 Create a HelloApp, the one we want to test, passing the mocks
    let app = HelloApp(message: message, console: console)
    // 2.5 Execute the method we want to test
    app.printHello()

    // 2.6 Verify HelloConsole mock print() method
    // has been called once with "Hello Test!"
    verify(console).print(👋: messageText)
  }
}

4) Test output should look like:

Test Suite 'All tests' started at 2023-12-12 16:48:21.225
Test Suite 'debug.xctest' started at 2023-12-12 16:48:21.227
Test Suite 'HelloAppTest' started at 2023-12-12 16:48:21.227
Test Case 'HelloAppTest.testHelloAppShouldDisplayHelloMessage' started at 2023-12-12 16:48:21.227
Test Case 'HelloAppTest.testHelloAppShouldDisplayHelloMessage' passed (0.003 seconds)
Test Suite 'HelloAppTest' passed at 2023-12-12 16:48:21.230
    Executed 1 test, with 0 failures (0 unexpected) in 0.003 (0.003) seconds
Test Suite 'HelloMessageTest' started at 2023-12-12 16:48:21.230
Test Case 'HelloMessageTest.testHelloMessageShouldReturnHelloWorld' started at 2023-12-12 16:48:21.231
Test Case 'HelloMessageTest.testHelloMessageShouldReturnHelloWorld' passed (0.001 seconds)
Test Suite 'HelloMessageTest' passed at 2023-12-12 16:48:21.232
    Executed 1 test, with 0 failures (0 unexpected) in 0.001 (0.001) seconds
Test Suite 'debug.xctest' passed at 2023-12-12 16:48:21.232
    Executed 2 tests, with 0 failures (0 unexpected) in 0.004 (0.004) seconds
Test Suite 'All tests' passed at 2023-12-12 16:48:21.232
    Executed 2 tests, with 0 failures (0 unexpected) in 0.004 (0.004) seconds

Happy Testing! 💙

Tests Everywhere - COBOL

Roger Viñas Alcon — Mon, 11 Dec 2023 09:45:30 +0000

rogervinas / tests-everywhere

🤠 Tests, Tests Everywhere!

COBOL testing this simple Hello World with cobol-check

Show me the code
- Implementation
- Test
Run this project using 🐳 docker
Run this project locally

Show me the code

Implementation

1) Create a program HELLO-CONSOLE in HELLO-CONSOLE.CBL:

Declare an alpha-numeric parameter MSG
Program will just display MSG

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO-CONSOLE.

DATA DIVISION.
LINKAGE SECTION.
01 MSG PIC A(20).

PROCEDURE DIVISION USING MSG.
    DISPLAY MSG.

2) Create a program HELLO in HELLO.CBL:

Declare an alpha-numeric variable MSG
Create HELLO-MESSAGE paragraph that sets a value to MSG variable
Create HELLO paragraph calling:
- HELLO-MESSAGE paragraph
- HELLO-CONSOLE program
Create MAIN paragraph just calling the HELLO paragraph

💡 We use a paragraph for HELLO-MESSAGE and a program for HELLO-CONSOLE just to show two different options and how to mock them in the tests.

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
WORKING-STORAGE SECTION.
01 MSG PIC A(20).

PROCEDURE DIVISION.

MAIN.
    PERFORM HELLO.
    STOP RUN.

HELLO.
    PERFORM HELLO-MESSAGE.
    CALL 'HELLO-CONSOLE' USING MSG.

HELLO-MESSAGE.
    MOVE 'HELLO WORLD!' TO MSG.

Test

Following A Brief Example, Mock a paragraph and Mock a CALL statement guides ...

In HELLO.cut file:

1) Test HELLO-MESSAGE paragraph:

TestSuite "HELLO-MESSAGE"

TestCase "SHOULD RETURN HELLO WORLD"
  MOVE "" TO MSG
  PERFORM HELLO-MESSAGE
  Expect MSG = "HELLO WORLD!"

2) Test HELLO paragraph mocking HELLO-MESSAGE and HELLO-CONSOLE:

TestSuite "HELLO"

TestCase "SHOULD DISPLAY HELLO MESSAGE"
  * 2.1 Mock HELLO-MESSAGE
  MOCK PARAGRAPH HELLO-MESSAGE
      MOVE "HELLO TEST!" TO MSG
  END-MOCK

  * 2.2 Mock HELLO-CONSOLE
  MOCK CALL 'HELLO-CONSOLE' USING MSG
      CONTINUE
  END-MOCK

  * 2.3 Execute the paragraph we want to test
  PERFORM HELLO

  * 2.4 Verify MSG has the expected value
  Expect MSG = "HELLO TEST!"
  * 2.5 Verify HELLO-MESSAGE has been called once
  VERIFY PARAGRAPH HELLO-MESSAGE HAPPENED ONCE
  * 2.6 Verify HELLO-CONSOLE has been called once
  VERIFY CALL 'HELLO-CONSOLE' USING MSG HAPPENED ONCE

3) Test output should look like:

TESTSUITE:
HELLO-MESSAGE
     PASS:   1. SHOULD RETURN HELLO WORLD
TESTSUITE:
HELLO
     PASS:   2. SHOULD DISPLAY HELLO MESSAGE
     PASS:   3. VERIFY EXACT 1 ACCESS TO PARAGRAPH HELLO-MESSAGE
     PASS:   4. VERIFY EXACT 1 ACCESS TO CALL 'HELLO-CONSOLE'

  4 TEST CASES WERE EXECUTED
  4 PASSED
  0 FAILED
  0 CALLS NOT MOCKED
================================================

I have no idea how to unit test HELLO-CONSOLE program as it seems cobol-check does not support PROCEDURE DIVISION USING X sections so I created this issue 🤞

Happy Testing! 💙

Tests Everywhere - Scala

Roger Viñas Alcon — Thu, 23 Nov 2023 00:25:51 +0000

rogervinas / tests-everywhere

🤠 Tests, Tests Everywhere!

Scala testing this simple Hello World with ScalaTest and Mockito

Show me the code
- Implementation
- Test
Run this project using 🐳 docker
Run this project locally

Show me the code

Implementation

Create HelloMessage class in HelloMessage.scala:

class HelloMessage:
  def text: String = "Hello World!"

We can create it as a class as Mockito is able to mock final classes.

Same way create HelloConsole class in HelloConsole.scala:

class HelloConsole:
  def print(text: String): Unit =
    println(text)

Create HelloApp class in HelloApp.scala:

class HelloApp(message: HelloMessage, console: HelloConsole):
  def printHello(): Unit =
    console.print(message.text)

Create main class in Main.scala that wraps it all together:

@main def main(): Unit =
  val message = HelloMessage()
  val console = HelloConsole()
  val app = HelloApp(message, console)
  app.printHello()

Test

Following ScalaTest > Writing your first test and ScalaTest + Mockito guides ...

Test HelloMessage in HelloMessageSpec.scala:

class HelloMessageSpec extends AnyFlatSpec {

  "A HelloMessage" should "return hello world" in {
    val message = HelloMessage()
    assertResult(message.text) {
      "Hello World!"
    }
  }
}

Test HelloApp in HelloAppSpec.scala:

class HelloAppSpec extends AnyFlatSpec {

  "A HelloApp" should "print hello message" in {
    val messageText = "Hello Test!"

    // 2.1 Create a mock of HelloMessage
    val message = mock[HelloMessage]
    // 2.2 Return "Hello Test!" whenever text is called
    when(message.text).thenReturn(messageText)

    // 2.3 Create a mock of HelloConsole
    val console = mock[HelloConsole]

    // 2.4 Create a HelloApp, the one we want to test, passing the mocks
    val app = HelloApp(message, console)
    // 2.5 Execute the method we want to test
    app.printHello()

    // 2.6 Verify HelloConsole mock print() method
    // has been called once with "Hello Test!"
    verify(console).print(messageText)
  }
}

Test output should look like:

[info] HelloMessageSpec:
[info] A HelloMessage
[info] - should return hello world
[info] HelloAppSpec:
[info] A HelloApp
[info] - should print hello message
[info] Run completed in 515 milliseconds.
[info] Total number of tests run: 2
[info] Suites: completed 2, aborted 0
[info] Tests: succeeded 2, failed 0, canceled 0, ignored 0, pending 0
[info] All tests passed.
[success] Total time: 6 s

Happy Testing! 💙

Tests Everywhere - Rust

Roger Viñas Alcon — Thu, 23 Nov 2023 00:23:01 +0000

rogervinas / tests-everywhere

🤠 Tests, Tests Everywhere!

Rust testing this simple Hello World with mockall

Show me the code
- Implementation
- Test
Run this project using 🐳 docker
Run this project locally

Show me the code

Implementation

Create HelloMessage trait and HelloWorldMessage implementation in hello_message.rs:

pub trait HelloMessage {
  fn text(&self) -> String;
}

pub struct HelloWorldMessage {}

impl HelloMessage for HelloWorldMessage {
  fn text(&self) -> String {
    return String::from("Hello World!");
  }
}

impl HelloWorldMessage {
  pub fn new() -> Self {
    Self {}
  }
}

Creating it as a trait will allow us to mock it for testing.

Note that we create a HelloWorldMessage::new() method just as a convention to create new instances, although we could just use HelloWorldMessage {}.

Same way create HelloConsole trait and HelloSystemConsole implementation in hello_console.rs:

pub trait HelloConsole {
  fn print(&self, text: String);
}

pub struct HelloSystemConsole {}

impl HelloConsole for HelloSystemConsole {
  fn print(&self, text: String) {
    println!("{}", text);
  }
}

impl HelloSystemConsole {
  pub fn new() -> Self {
    Self {}
  }
}

Create HelloApp class in hello_app.rs:

pub struct HelloApp {
  message: Box<dyn HelloMessage>,
  console: Box<dyn HelloConsole>
}

impl HelloApp {
  pub fn new(message: Box<dyn HelloMessage>, console: Box<dyn HelloConsole>) -> Self {
    Self { message, console }
  }

  pub fn print_hello(&self) {
    self.console.print(self.message.text());
  }
}

Note that we pass constructor arguments as Box<dyn T> to avoid doesn't have a size known at compile-time compilation error.

Create main function in main.rs that wraps it all together:

fn main() {
  let message = HelloWorldMessage::new();
  let console = HelloSystemConsole::new();
  let app = HelloApp::new(Box::new(message), Box::new(console));
  app.print_hello();
}

Test

Following Rust By Example > Unit testing and mockall > Getting Started guides ...

Test HelloMessage in hello_message.rs:

#[cfg(test)]
mod tests {
  use super::*;

  #[test]
  fn should_return_hello_world() {
    let message = HelloWorldMessage::new();
    assert_eq!(message.text(), String::from("Hello World!"))
  }
}

Setup HelloMessage mocking needed by HelloApp test in hello_message.rs:

// 2.1 Enable automock
#[cfg(test)]
use mockall::automock;

// 2.2 Enable automock for HelloMessage
#[cfg_attr(test, automock)]
pub trait HelloMessage {
  fn text(&self) -> String;
}

Setup HelloConsole mocking needed by HelloApp test in hello_console.rs:

// 3.1 Enable automock
#[cfg(test)]
use mockall::automock;

// 3.2 Enable automock for HelloConsole
#[cfg_attr(test, automock)]
pub trait HelloConsole {
  fn print(&self, text: String);
}

Test HelloApp in hello_app.rs:

#[cfg(test)]
mod tests {
  use super::*;
  use mockall::predicate::*;
  // 4.1 Use MockHelloMessage, enabled by 2.2
  use crate::hello_message::MockHelloMessage;
  // 4.2 Use MockHelloConsole, enabled by 3.2
  use crate::hello_console::MockHelloConsole;

  #[test]
  fn should_print_hello_message() {
    let message_text = "Hello Test!";

    // 4.3 Create a mock of HelloMessage
    let mut message = MockHelloMessage::new();
    // 4.4 Return "Hello Test!" whenever text is called
    message.expect_text().return_const(String::from(message_text));

    // 4.5 Create a mock of HelloConsole
    let mut console = MockHelloConsole::new();
    // 4.6 Expect print to be called once with "Hello Test!"
    console.expect_print()
      .with(eq(String::from(message_text)))
      .times(1)
      .return_const(());

    // 4.7 Create a HelloApp, the one we want to test, passing the mocks
    let app = HelloApp::new(Box::new(message), Box::new(console));
    // 4.8 Execute the method we want to test
    app.print_hello();

    // Expectation 4.6 will be checked once test ends
  }
}

Test output should look like:

running 2 tests
test hello_app::tests::should_print_hello_message ... ok
test hello_message::tests::should_return_hello_world ... ok

test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

Happy Testing! 💙

Tests Everywhere - Ruby

Roger Viñas Alcon — Thu, 23 Nov 2023 00:19:46 +0000

rogervinas / tests-everywhere

🤠 Tests, Tests Everywhere!

Ruby testing this simple Hello World with RSpec

Show me the code
- Implementation
- Test
Run this project using 🐳 docker
Run this project locally

Show me the code

Implementation

Create HelloMessage class in HelloMessage.rb:

class HelloMessage
  def text
    @text = "Hello World!"
  end
end

Create HelloConsole class in HelloConsole.rb:

class HelloConsole
  def print(text)
    puts text
  end
end

Create HelloApp class in HelloApp.rb:

class HelloApp
  def initialize(message, console)
    @message = message
    @console = console
  end

  def printHello
    @console.print(@message.text)
  end
end

Create main function in Main.rb that wraps it all together:

message = HelloMessage.new
console = HelloConsole.new
app = HelloApp.new message, console
app.printHello

Test

Following RSpec Core and RSpec Mocks guides ...

Test HelloMessage in HelloMessage_spec.rb:

RSpec.describe HelloMessage do
  it "should return hello world" do
    message = HelloMessage.new
    expect(message.text).to eq("Hello World!")
  end
end

Test HelloApp in HelloApp_spec.rb:

RSpec.describe HelloApp do
  it "should print hello message" do
    messageText = "Hello Test!"

    # 2.1 Create a mock of HelloMessage
    # that will return "Hello Test!" whenever text is called
    message = instance_double("HelloMessage", :text => messageText)

    # 2.2 Create a mock of HelloConsole
    console = instance_double("HelloConsole")
    # 2.3 Expect print to be called once with "Hello Test!"
    expect(console).to receive(:print).once.with(messageText)

    # 2.4 Create a HelloApp, the one we want to test, passing the mocks
    app = HelloApp.new message, console
    # 2.5 Execute the method we want to test
    app.printHello

    # Expectation 2.3 will be checked once test ends
  end
end

Test output should look like:

HelloApp
  should print hello message

HelloMessage
  should return hello world

Finished in 0.00457 seconds (files took 0.05704 seconds to load)
2 examples, 0 failures

Happy Testing! 💙

Tests Everywhere - Python

Roger Viñas Alcon — Thu, 23 Nov 2023 00:15:04 +0000

rogervinas / tests-everywhere

🤠 Tests, Tests Everywhere!

Python testing this simple Hello World with unittest

Show me the code
- Implementation
- Test
Run this project using 🐳 docker
Run this project locally

Show me the code

Implementation

Create HelloMessage class in hello_message.py:

class HelloMessage:
  def __init__(self):
    self.text = "Hello World!"

Create HelloConsole class in hello_console.py:

from builtins import print as __print__

class HelloConsole:
  def print(self, text):
    __print__(text)

Note that we have to import print system function as __print__ to avoid conflict with HelloConsole own print method.

Create HelloApp class in hello_app.py:

class HelloApp:
  def __init__(self, message, console):
    self.message = message
    self.console = console

  def print_hello(self):
    self.console.print(self.message.text)

Create main function in __main__.py that wraps it all together:

message = HelloMessage()
console = HelloConsole()
app = HelloApp(message, console)
app.print_hello()

Test

Following unittest > Basic example and unittest.mock > Quick Guide guides ...

Test HelloMessage in test_hello_message.py:

class HelloMessageTest(unittest.TestCase):
  def test_should_return_hello_world(self):
    message = HelloMessage()
    self.assertEqual(message.text, "Hello World!")

Test HelloApp in test_hello_app.py:

class HelloAppTest(unittest.TestCase):
  def test_should_print_hello_message(self):
    message_text = "Hello Test!"

    # 2.1 Create a mock of HelloMessage
    message = MagicMock()
    # 2.2 Return "Hello Test!" whenever text is called
    message.text = message_text

    # 2.3 Create a mock of HelloConsole
    console = MagicMock()
    # 2.4 Mock print method
    console.print = MagicMock()

    # 2.5 Create a HelloApp, the one we want to test, passing the mocks
    app = HelloApp(message, console)
    # 2.6 Execute the method we want to test
    app.print_hello()

    # 2.7 Verify HelloConsole mock print() method
    # has been called once with "Hello Test!"
    console.print.assert_called_once_with(message_text)

Test output should look like:

test_should_print_hello_message (test.test_hello_app.HelloAppTest.test_should_print_hello_message) ... ok
test_should_return_hello_world (test.test_hello_message.HelloMessageTest.test_should_return_hello_world) ... ok

----------------------------------------------------------------------
Ran 2 tests in 0.001s

OK

Happy Testing! 💙

Tests Everywhere - Kotlin

Roger Viñas Alcon — Thu, 23 Nov 2023 00:12:28 +0000

rogervinas / tests-everywhere

🤠 Tests, Tests Everywhere!

Kotlin testing this simple Hello World with Kotest and MockK

Show me the code
- Implementation
- Test
Run this project using 🐳 docker
Run this project locally

Show me the code

Implementation

Create HelloMessage class in HelloMessage.kt:

class HelloMessage {
  val text: String = "Hello World!"
}

We can create it as a class as MockK is able to mock final classes.

Same way create HelloConsole class in HelloConsole.kt:

class HelloConsole {
  fun print(text: String) {
    println(text)
  }
}

Create HelloApp class in HelloApp.kt:

class HelloApp(private val message: HelloMessage, private val console: HelloConsole) {
  fun printHello() {
    console.print(message.text)
  }
}

Create main class in Main.kt that wraps it all together:

fun main() {
  val message = HelloMessage()
  val console = HelloConsole()
  val app = HelloApp(message, console)
  app.printHello()
}

Test

Following Kotest > Writing Tests and MockK > Class mock guides ...

Test HelloMessage in HelloMessageTest.kt:

class HelloMessageTest : DescribeSpec({

  describe("HelloMessage") {
    it("should return hello world") {
      val message = HelloMessage()
      message.text shouldBe "Hello World!"
    }
  }
})

Test HelloApp in HelloAppTest.kt:

class HelloAppTest : DescribeSpec({

  describe("HelloApp") {
    it("should print hello message") {
      val messageText = "Hello Test!"

      // 2.1 Create a mock of HelloMessage
      val message = mockk<HelloMessage>()
      // 2.2 Return "Hello Test!" whenever text is called
      every { message.text } returns (messageText)

      // 2.3 Create a mock of HelloConsole
      val console = mockk<HelloConsole>()
      // 2.4 Do nothing whenever print is called
      every { console.print(any()) } just Runs

      // 2.5 Create a HelloApp, the one we want to test, passing the mocks
      val app = HelloApp(message, console)
      // 2.6 Execute the method we want to test
      app.printHello()

      // 2.7 Verify HelloConsole mock print() method
      // has been called once with "Hello Test!"
      verify { console.print(messageText) }
    }
  }
})

Test output should look like:

> Task :test

org.hello.HelloAppTest > HelloApp > should print hello message PASSED

org.hello.HelloMessageTest > HelloMessage > should return hello world PASSED

BUILD SUCCESSFUL in 3s

Happy Testing! 💙

Tests Everywhere - JavaScript

Roger Viñas Alcon — Thu, 23 Nov 2023 00:09:06 +0000

rogervinas / tests-everywhere

🤠 Tests, Tests Everywhere!

JavaScript testing this simple Hello World with Jest

Show me the code
- Implementation
- Test
Run this project using 🐳 docker
Run this project locally

Show me the code

Implementation

Create HelloMessage class in HelloMessage.js:

class HelloMessage {
  text = "Hello World!";
}

Create HelloConsole class in HelloConsole.js:

class HelloConsole {
  print(text) {
    console.log(text);
  }
}

Create HelloApp class in HelloApp.js:

class HelloApp {
  constructor(helloMessage, helloConsole) {
    this.helloMessage = helloMessage;
    this.helloConsole = helloConsole;
  }

  printHello() {
    this.helloConsole.print(this.helloMessage.text);
  }
}

Create main function in Main.js that wraps it all together:

const HelloMessage = require("./HelloMessage");
const HelloConsole = require("./HelloConsole");
const HelloApp = require("./HelloApp");

const message = new HelloMessage();
const console = new HelloConsole();
const app = new HelloApp(message, console);
app.printHello();

Test

Following Jest > Getting Started guide ...

Test HelloMessage in HelloMessage.test.js:

describe("HelloMessage", () => {
  it("should return hello world", () => {
    const message = new HelloMessage();
    expect(message.text).toBe("Hello World!");
  });
});

Test HelloApp in HelloApp.test.js:

// 2.1 Mock ./HelloMessage module
jest.mock("./HelloMessage");
// 2.2 Mock ./HelloConsole module
jest.mock("./HelloConsole");

describe("HelloApp", () => {
  it("should print hello message", () => {
    const messageText = "Hello Test!";

    // 2.3 Set mock implementation to be returned
    // anytime new HelloMessage() is called
    HelloMessage.mockImplementation(() => {
      return {
        text: messageText,
      };
    });
    // 2.4 Create a HelloMessage
    // that will be a mock thanks to 2.1 and 2.2
    const message = new HelloMessage();

    // 2.5 Create a HelloConsole
    // that will be a mock thanks to 2.3
    const console = new HelloConsole();

    // 2.6 Create a HelloApp, the one we want to test, passing the mocks
    const app = new HelloApp(message, console);
    // 2.7 Execute the method we want to test
    app.printHello();

    // 2.8 Verify HelloConsole mock print() method
    // has been called once with "Hello Test!"
    expect(console.print).toHaveBeenCalledTimes(1);
    expect(console.print).toHaveBeenCalledWith(messageText);
  });
});

Test output should look like:

> jest

 PASS  ./HelloMessage.test.js
 PASS  ./HelloApp.test.js

Test Suites: 2 passed, 2 total
Tests:       2 passed, 2 total
Snapshots:   0 total
Time:        1.229 s
Ran all test suites.

Happy Testing! 💙

Tests Everywhere - Java

Roger Viñas Alcon — Thu, 23 Nov 2023 00:00:13 +0000

rogervinas / tests-everywhere

🤠 Tests, Tests Everywhere!

Java testing this simple Hello World with JUnit5, Mockito and AssertJ

Show me the code
- Implementation
- Test
Run this project using 🐳 docker
Run this project locally

Show me the code

Implementation

Create HelloMessage class in HelloMessage.java:

public class HelloMessage {
  public String getText() {
    return "Hello World!";
  }
}

We can create it as a class as Mockito is able to mock final classes.

Same way create HelloConsole class in HelloConsole.java:

public class HelloConsole {
  public void print(String text) {
    System.out.println(text);
  }
}

Create HelloApp class in HelloApp.java:

public class HelloApp {

  private final HelloMessage message;
  private final HelloConsole console;

  public HelloApp(HelloMessage message, HelloConsole console) {
    this.message = message;
    this.console = console;
  }

  public void printHello() {
    console.print(message.getText());
  }
}

Create main class in Main.java that wraps it all together:

public class Main {

  public static void main(String[] args) {
    var message = new HelloMessage();
    var console = new HelloConsole();
    var app = new HelloApp(message, console);
    app.printHello();
  }
}

Test

Following JUnit5 > Writing Tests, Mockito > Stubbing and AssertJ > Core assertions guide guides ...

Test HelloMessage in HelloMessageTest.java:

@Test
void shouldReturnHelloWorld() {
  var message = new HelloMessage();
  assertThat(message.getText()).isEqualTo("Hello World!");
}

Test HelloApp in HelloAppTest.java:

@Test
void shouldPrintHelloMessage() {

  var messageText = "Hello Test!";

  // 2.1 Create a mock of HelloMessage
  var message = mock(HelloMessage.class);
  // 2.2 Return "Hello Test!" whenever getText() is called
  when(message.getText()).thenReturn(messageText);

  // 2.2 Create a mock of HelloConsole
  var console = mock(HelloConsole.class);

  // 2.3 Create a HelloApp, the one we want to test, passing the mocks
  var app = new HelloApp(message, console);
  // 2.4 Execute the method we want to test
  app.printHello();

  // 2.5 Verify HelloConsole mock print() method
  // has been called once with "Hello Test!"
  verify(console).print(messageText);
}

Test output should look like:

> Task :test

HelloAppTest > shouldPrintHelloMessage() PASSED

HelloMessageTest > shouldReturnHelloWorld() PASSED

BUILD SUCCESSFUL in 2s

Happy Testing! 💙

Tests Everywhere - Go

Roger Viñas Alcon — Wed, 22 Nov 2023 23:56:58 +0000

rogervinas / tests-everywhere

🤠 Tests, Tests Everywhere!

Go testing this simple Hello World with Standard library

Show me the code
- Implementation
- Test
Run this project using 🐳 docker
Run this project locally

Show me the code

Implementation

Create HelloMessage interface and HelloWorldMessage implementation in HelloMessage.go:

type HelloMessage interface {
  Text() string
}

type HelloWorldMessage struct{}

func (message *HelloWorldMessage) Text() string {
  return "Hello World!"
}

Creating it as an interface will allow us to mock it for testing.

Same way create HelloConsole interface and HelloSystemConsole implementation in HelloConsole.go:

type HelloConsole interface {
  Print(text string)
}

type HelloSystemConsole struct{}

func (console *HelloSystemConsole) Print(text string) {
  fmt.Println(text)
}

Create HelloApp class in HelloApp.go:

type HelloApp struct {
  message HelloMessage
  console HelloConsole
}

func (app *HelloApp) PrintHello() {
  app.console.Print(app.message.Text())
}

Create main function in Main.go that wraps it all together:

func main() {
  message := HelloWorldMessage{}
  console := HelloSystemConsole{}
  app := HelloApp{&message, &console}
  app.PrintHello()
}

Test

Following Standard library > testing guide ...

Test HelloMessage in HelloMessage_test.go:

func TestShouldReturnHelloWorld(t *testing.T) {
  messageText := "Hello World!"
  message := HelloWorldMessage{}
  if message.Text() != messageText {
    t.Fatalf("Expected %s but got %s", messageText, message.Text())
  }
}

Test HelloApp in HelloApp_test.go:

// 2.1 Define a HelloMessageMock struct that ...
type HelloMessageMock struct {
  text string
}

// ... fullfils HelloMessage interface
func (message *HelloMessageMock) Text() string {
  return message.text
}

// 2.2 Define a HelloConsoleMock that ...
type HelloConsoleMock struct {
  Calls int
  Text  string
}

// ... fullfills HelloConsole interface
func (console *HelloConsoleMock) Print(text string) {
  console.Calls++
  console.Text = text
}

func TestShouldReturnPrintHelloMessage(t *testing.T) {

  messageText := "Hello Test!"

  // 2.3 Create a HelloMessageMock
  // that will return "Hello Test!"
  message := HelloMessageMock{messageText}

  // 2.4 Create a HelloConsoleMock
  // that will capture its calls
  console := HelloConsoleMock{}

  // 2.5 Create a HelloApp, the one we want to test, passing the mocks
  app := HelloApp{&message, &console}
  // 2.6 Execute the method we want to test
  app.PrintHello()

  // 2.7 Assert HelloConsoleMock has been called once
  if console.Calls != 1 {
    t.Fatalf("HelloConsole expected calls 1 but got %d", console.Calls)
  }

  // 2.8 Assert HelloConsoleMock has been called with "Hello Test!"
  if console.Text != messageText {
    t.Fatalf("HelloConsole expected text %s but got %s", messageText, console.Text)
  }
}

Test output should look like:

=== RUN   TestShouldReturnPrintHelloMessage
--- PASS: TestShouldReturnPrintHelloMessage (0.00s)
=== RUN   TestShouldReturnHelloWorld
--- PASS: TestShouldReturnHelloWorld (0.00s)
PASS
ok      org.hello/main  0.412s

Happy Testing! 💙

Tests Everywhere - .NET C#

Roger Viñas Alcon — Wed, 22 Nov 2023 23:51:51 +0000

rogervinas / tests-everywhere

🤠 Tests, Tests Everywhere!

.NET C# testing this simple Hello World with NUnit and Moq

Show me the code
- Implementation
- Test
Run this project using 🐳 docker
Run this project locally

Show me the code

Implementation

Create HelloMessage interface and HelloWorldMessage implementing it in HelloMessage.cs:

public interface HelloMessage
{
  public String Text {
    get;
  }
}

public class HelloWorldMessage : HelloMessage
{
  public string Text {
    get {
      return "Hello World!";
    }
  }
}

Creating it as an interface will allow us to mock it for testing using Moq which does not support mocking final classes. Maybe other libraries support that but using an interface is simpler.

Same way create HelloConsole interface and HelloSystemConsole class implementing it in HelloConsole.cs:

public interface HelloConsole {
  void Print(String text);
}

public class HelloSystemConsole : HelloConsole
{
  public void Print(String text) {
    Console.WriteLine(text);
  }
}

Create HelloApp in HelloApp.cs:

public class HelloApp
{
  private HelloMessage message;
  private HelloConsole console;

  public HelloApp(HelloMessage message, HelloConsole console) {
    this.message = message;
    this.console = console;
  }

  public void PrintHello() {
    console.Print(message.Text);
  }
}

Create main Hello.Main/Program.cs that wraps it all together:

var message = new HelloWorldMessage();
var console = new HelloSystemConsole();
var app = new HelloApp(message, console);
app.PrintHello();

Test

Following NUnit > Writing Tests and Moq guides ...

Test HelloMessage in HelloMessageTest.cs:

[Test]
public void ShouldReturnHelloWorld()
{
  var message = new HelloWorldMessage();
  Assert.That(message.Text, Is.EqualTo("Hello World!"));
}

Test HelloApp in HelloAppTest.cs:

[Test]
public void ShouldPrintHelloMessage()
{
  var messageText = "Hello Test!";

  // 2.1 Create a mock of HelloMessage
  var messageMock = new Mock<HelloMessage>();
  // 2.2 Expect HelloMessage mock to receive a call to Text
  // and return "Hello Test!"
  messageMock.Setup(message => message.Text).Returns(messageText);
  // 2.3 Get the mock object to pass it to HelloApp
  var message = messageMock.Object;

  // 2.4 Create a mock of HelloConsole
  var consoleMock = new Mock<HelloConsole>();
  // 2.5 No need to set expectations for this one
  // 2.6 Get the mock object to pass it to HelloApp
  var console = consoleMock.Object;

  // 2.3 Create a HelloApp, the one we want to test, passing the mocks
  var app = new HelloApp(message, console);
  // 2.4 Execute the method we want to test
  app.PrintHello();

  // 2.5 Verify HelloConsole mock Print() method
  // has been called once with "Hello Test!"
  consoleMock.Verify(console => console.Print(messageText), Times.Once);
}

Test output should look like:

NUnit Adapter 4.2.0.0: Test execution complete
  Passed ShouldPrintHelloMessage [180 ms]
  Passed ShouldReturnHelloWorld [7 ms]

Test Run Successful.
Total tests: 2
     Passed: 2
 Total time: 2.7702 Seconds

Happy Testing! 💙