Employee Service Application

Oct 13, 2025 by recoveryshake.com 96 views

Introduction

As software development continues to evolve, integration testing has become a crucial aspect of ensuring the quality and reliability of microservices-based applications. In this article, we will explore how to register a mocked server to a discovery test container using OpenFeign and Wiremock in Spring Boot integration testing.

What is Integration Testing?

Integration testing is a type of software testing that involves testing the interactions between different components or modules of an application. It helps to ensure that the different parts of the system work together seamlessly and that the application behaves as expected in different scenarios.

Why Mock a Microservice in Integration Tests?

Mocking a microservice in integration tests is essential when using Feign and Eureka for service discovery. When you're testing a controller layer, you want to isolate the dependencies and focus on the behavior of the controller without being affected by the actual microservice. This is where Wiremock comes in – a powerful tool for mocking HTTP requests and responses.

Setting Up the Project

To demonstrate how to register a mocked server to a discovery test container using OpenFeign and Wiremock, we'll create a simple Spring Boot project. Our project will consist of two microservices: Employee Service and Department Service. The Employee Service will use OpenFeign to call the Department Service.

Project Structure

com.example
EmployeeService
EmployeeController
EmployeeServiceApplication
DepartmentService
DepartmentController
DepartmentServiceApplication
pom.xml

Dependencies

In the pom.xml file, we'll add the necessary dependencies for Spring Boot, OpenFeign, and Wiremock.

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-openfeign</artifactId>
    </dependency>
    <dependency>
        <groupId>com.github.tomakehurst</groupId>
        <artifactId>wiremock-standalone</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

Employee Service Application

In the EmployeeServiceApplication class, we'll enable OpenFeign and configure the Eureka client.

@SpringBootApplication
@EnableFeignClients
@EnableDiscoveryClient
public class EmployeeServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(EmployeeServiceApplication.class, args);
    }
}

Department Service Application

In the DepartmentServiceApplication class, we'll enable OpenFeign and configure the Eureka client.

@SpringBootApplication
@EnableFeignClients
@EnableDiscoveryClient
public class DepartmentServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(DepartmentServiceApplication.class, args);
    }
}

Employee Controller

In the EmployeeController class, we'll use OpenFeign to call the Department Service.

@RestController
@RequestMapping("/employees")
public class EmployeeController {
    @Autowired
    private EmployeeService employeeService;
@GetMapping
public List&lt;Employee&gt; getEmployees() {
    return employeeService.getEmployees();
}

}

Department Controller

In the DepartmentController class, we'll handle HTTP requests and responses.

@RestController
@RequestMapping("/departments")
public class DepartmentController {
    @GetMapping
    public List<Department> getDepartments() {
        return Arrays.asList(new Department("IT"), new Department("HR"));
    }
}

Wiremock Configuration

In the WiremockConfig class, we'll configure Wiremock to mock the Department Service.

@Configuration
public class WiremockConfig {
    @Bean
    public WireMockServer wireMockServer() {
        WireMockServer wireMockServer = new WireMockServer(WireMockConfiguration.wireMockConfig().port(8081));
        wireMockServer.start();
        return wireMockServer;
    }
}

Test Container Configuration

In the TestContainerConfig class, we'll configure the Test Container to run the Department Service.

@Configuration
public class TestContainerConfig {
    @Bean
    public TestContainerFactory testContainerFactory() {
        return new GenericTestContainerFactory();
    }
@Bean
public TestContainer departmentServiceTestContainer() {
    TestContainer testContainer = new GenericTestContainer(&quot;department-service:latest&quot;);
    testContainer.start();
    return testContainer;
}

}

Integration Test

In the EmployeeServiceIntegrationTest class, we'll test the Employee Service using Wiremock and the Test Container.

@SpringBootTest
public class EmployeeServiceIntegrationTest {
    @Autowired
    private EmployeeService employeeService;
@Autowired
private WireMockServer wireMockServer;

@Autowired
private TestContainer departmentServiceTestContainer;

@Test
public void testGetEmployees() {
    // Given
    Department department = new Department(&quot;IT&quot;);
    wireMockServer.stubFor(get(urlEqualTo(&quot;/departments&quot;))
            .willReturn(aResponse().withStatus(200).withBody(asJsonString(Arrays.asList(department)))));

    // When
    List&lt;Employee&gt; employees = employeeService.getEmployees();

    // Then
    assertEquals(1, employees.size());
    assertEquals(&quot;IT&quot;, employees.get(0).getDepartment().getName());
}

}

Conclusion

In this article, we've demonstrated how to register a mocked server to a discovery test container using OpenFeign and Wiremock in Spring Boot integration testing. We've created a simple Spring Boot project with two microservices: Employee Service and Department Service. We've used Wiremock to mock the Department Service and the Test Container to run the Department Service. We've written an integration test to test the Employee Service using Wiremock and the Test Container. This approach allows us to isolate the dependencies and focus on the behavior of the controller without being affected by the actual microservice.

Best Practices

Use Wiremock to mock HTTP requests and responses.
Use the Test Container to run the microservice.
Isolate the dependencies and focus on the behavior of the controller.
Write integration tests to test the microservice.

Future Work

Explore other mocking tools such as Mockito and OkHttp MockWebServer.
Investigate other test container options such as Docker and Kubernetes.
Develop more complex integration tests to cover different scenarios.
Spring Boot Integration Testing: Q&A =====================================

Introduction

In our previous article, we explored how to register a mocked server to a discovery test container using OpenFeign and Wiremock in Spring Boot integration testing. In this article, we'll answer some frequently asked questions about Spring Boot integration testing.

Q: What is the difference between unit testing and integration testing?

A: Unit testing involves testing individual units of code, such as methods or classes, in isolation. Integration testing, on the other hand, involves testing how different units of code work together to achieve a specific goal.

Q: Why do I need to use a test container in my integration tests?

A: A test container allows you to run your application in a controlled environment, making it easier to test and debug your code. It also helps to isolate dependencies and ensures that your tests are not affected by external factors.

Q: How do I configure Wiremock to mock a specific endpoint?

A: You can configure Wiremock to mock a specific endpoint by using the stubFor method. For example:

wireMockServer.stubFor(get(urlEqualTo("/departments"))
        .willReturn(aResponse().withStatus(200).withBody(asJsonString(Arrays.asList(department))));

Q: How do I use the Test Container to run my application?

A: You can use the Test Container to run your application by creating a TestContainer instance and starting it. For example:

@TestContainer
public class EmployeeServiceTestContainer {
    @Test
    public void testGetEmployees() {
        // Given
        Department department = new Department("IT");
        wireMockServer.stubFor(get(urlEqualTo("/departments"))
                .willReturn(aResponse().withStatus(200).withBody(asJsonString(Arrays.asList(department)))));
    // When
    List&lt;Employee&gt; employees = employeeService.getEmployees();

    // Then
    assertEquals(1, employees.size());
    assertEquals(&quot;IT&quot;, employees.get(0).getDepartment().getName());
}

}

Q: How do I write integration tests for my Spring Boot application?

A: You can write integration tests for your Spring Boot application by using the @SpringBootTest annotation. For example:

@SpringBootTest
public class EmployeeServiceIntegrationTest {
    @Autowired
    private EmployeeService employeeService;
@Autowired
private WireMockServer wireMockServer;

@Autowired
private TestContainer departmentServiceTestContainer;

@Test
public void testGetEmployees() {
    // Given
    Department department = new Department(&quot;IT&quot;);
    wireMockServer.stubFor(get(urlEqualTo(&quot;/departments&quot;))
            .willReturn(aResponse().withStatus(200).withBody(asJsonString(Arrays.asList(department)))));

    // When
    List&lt;Employee&gt; employees = employeeService.getEmployees();

    // Then
    assertEquals(1, employees.size());
    assertEquals(&quot;IT&quot;, employees.get(0).getDepartment().getName());
}

}

Q: How do I use OpenFeign to call a remote service?

A: You can use OpenFeign to call a remote service by creating a Feign client and annotating it with @FeignClient. For example:

@FeignClient(name = "department-service")
public interface DepartmentService {
    @GetMapping("/departments")
    List<Department> getDepartments();
}

Q: How do I use Wiremock to mock a remote service?

A: You can use Wiremock to mock a remote service by creating a Wiremock server and stubbing the endpoint you want to mock. For example:

wireMockServer.stubFor(get(urlEqualTo("/departments"))
        .willReturn(aResponse().withStatus(200).withBody(asJsonString(Arrays.asList(department))));

Conclusion

In this article, we've answered some frequently asked questions about Spring Boot integration testing. We've covered topics such as unit testing vs integration testing, test containers, Wiremock, OpenFeign, and more. We hope this article has been helpful in answering your questions and providing you with a better understanding of Spring Boot integration testing.

Best Practices

Use Wiremock to mock HTTP requests and responses.
Use the Test Container to run your application.
Isolate dependencies and focus on the behavior of the controller.
Write integration tests to test your application.

Future Work

Explore other mocking tools such as Mockito and OkHttp MockWebServer.
Investigate other test container options such as Docker and Kubernetes.
Develop more complex integration tests to cover different scenarios.