jakarta.servlet.ServletException, different behaviour between run, test and http request with SpringBoot API

I am building a SpringBoot API to learn the framework and I am facing two curious problems which probably are linked in some way.

First problem, when I try to test my code with my own Junit test class called EmployeeControllerTest, calling the method with http request returns the following error :
jakarta.servlet.ServletException: Request processing failed: java.util.NoSuchElementException: No value present

Second problem, when I perform those tests with Postman, the request /employees returning the list of employees works perfectly but the request /employee (with or without id added to the url), the API returns nothing.

In addition to this, calling the method from inside the code (in the run class) works great, I have every result I need.

Here are the code of every part involved. First the model class :

package com.openclassrooms.api.models;

import jakarta.persistence.*;

import lombok.Data;

@Data
@Entity
@Table(name = "employees")
public class Employee {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "first_name")
    private String firstName;

    @Column(name = "last_name")
    private String lastName;

    private String mail;

    private String password;

}

The repository class :

package com.openclassrooms.api.repository;

import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;

import com.openclassrooms.api.models.Employee;

@Repository
public interface EmployeeRepository extends CrudRepository<Employee, Long> {

}

The service class :

package com.openclassrooms.api.service;

import java.util.Optional;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.openclassrooms.api.models.Employee;
import com.openclassrooms.api.repository.EmployeeRepository;

@Service
public class EmployeeService {

    @Autowired
    private EmployeeRepository employeeRepository;

    public Optional<Employee> getEmployee(final Long id) {
        System.out.println("getEmployee ok");
        return employeeRepository.findById(id);
    }

    public Iterable<Employee> getEmployees() {
        System.out.println("getEmployees ok");
        return employeeRepository.findAll();
    }

    public void deleteEmployee(final Long id) {
        employeeRepository.deleteById(id);
    }

    public Employee saveEmployee(Employee employee) {
        Employee savedEmployee = employeeRepository.save(employee);
        return savedEmployee;
    }

}

and the controller class :

package com.openclassrooms.api.controller;

import java.util.Optional;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

import com.openclassrooms.api.models.Employee;
import com.openclassrooms.api.service.EmployeeService;

@RestController
public class EmployeeController {

    @Autowired
    private EmployeeService employeeService;

    // Read - Get all employees

    // @return - An Iterable object of Employee full filled

    @GetMapping("/employees")
    public Iterable<Employee> getEmployees() {
        Iterable<Employee> list = employeeService.getEmployees();
        System.out.println(list);
        return list;
    }

    @GetMapping("/employee/{id}")
    public Employee getEmployee(@PathVariable("id") final Long id) {
        Optional<Employee> emp = employeeService.getEmployee(id);

        if (emp.isEmpty()) {
            Employee employe = emp.get();
            System.out.println(employe.getFirstName());
            return employe;
        } else {
            System.out.println("ABSENT");
            return null;
        }
    }

    @GetMapping("/employee")
    public Employee getEmployee() {
        Optional<Employee> emp = employeeService.getEmployee(1L);

        if (emp.isEmpty()) {
            Employee employe = emp.get();
            System.out.println(employe.getFirstName());
            return employe;
        } else {
            System.out.println("ABSENT");
            return null;
        }
    }
}

Additionnaly, the main and test classes :

package com.openclassrooms.api;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

import com.openclassrooms.api.models.Employee;
import com.openclassrooms.api.service.EmployeeService;

@SpringBootApplication
public class ApiApplication implements CommandLineRunner {

	@Autowired
	private EmployeeService employeeService;

	public static void main(String[] args) {

		SpringApplication.run(ApiApplication.class, args);
	}

	public void run(String... args) throws Exception {

		if (employeeService.getEmployee(1L).isPresent()) {

			Employee emp1 = employeeService.getEmployee(1L).get();
			System.out.println(emp1.getFirstName() + " " + emp1.getLastName());

		} else {
			System.out.println("Erreur, employé absent.");
		}

		System.out.println(employeeService.getEmployees());
	}

}

package com.openclassrooms.api;

import static org.hamcrest.CoreMatchers.is;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;

import java.io.PrintStream;

import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureWebMvc;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
//import org.springframework.test.web.servlet.ResultMatcher;
import org.springframework.test.web.servlet.ResultHandler;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.openclassrooms.api.controller.EmployeeController;
import com.openclassrooms.api.models.Employee;
import com.openclassrooms.api.service.EmployeeService;

//@SpringBootTest
//@AutoConfigureWebMvc
@WebMvcTest(controllers = EmployeeController.class)
public class EmployeeControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @MockBean
    private EmployeeService employeeService;

    @Test
    public void testGetEmployees() throws Exception {
        Employee response = new Employee();

        mockMvc.perform(get("/employee"))
                .andExpect(status().isOk())
                .andDo(print(System.out))
                .andExpect(jsonPath("$.firstName").value("Laurent"));

                //.andExpect(jsonPath("$[0].firstName", is("Laurent")));
    }
}

Thanks in advance for any answer !

EDIT : the SQL script used when building the database :

<!-- begin snippet: js hide: false console: true babel: false -->

<!-- language: lang-sql -->

DROP TABLE IF EXISTS employees;
 
CREATE TABLE employees (
  id INT AUTO_INCREMENT  PRIMARY KEY,
  first_name VARCHAR(250) NOT NULL,
  last_name VARCHAR(250) NOT NULL,
  mail VARCHAR(250) NOT NULL,
  password VARCHAR(250) NOT NULL
)
 
INSERT INTO employees (first_name, last_name, mail, password) VALUES
  ('Laurent', 'GINA', 'laurentgina@mail.com', 'laurent'),
  ('Sophie', 'FONCEK', 'sophiefoncek@mail.com', 'sophie'),
  ('Agathe', 'FEELING', 'agathefeeling@mail.com', 'agathe');

<!-- end snippet -->

There seems to be a couple of issues with the code.

First, in the getEmployee method of the EmployeeController class, the if condition checks if the Optional<Employee> returned by the employeeService is empty, but if it's empty, the code returns null, which is not the desired behavior. Instead, you should check if the Optional is present, and if it is, return the value, otherwise return an appropriate response indicating that the employee was not found.

@GetMapping("/employee/{id}")
public Employee getEmployee(@PathVariable("id") final Long id) {
    Optional<Employee> emp = employeeService.getEmployee(id);

    if (emp.isPresent()) {
        Employee employe = emp.get();
        System.out.println(employe.getFirstName());
        return employe;
    } else {
        System.out.println("ABSENT");
        // return an appropriate response indicating that the employee was not found
        return null;
    }
}

The same issue applies to the getEmployee method without a path variable.

@GetMapping("/employee")
public Employee getEmployee() {
    Optional<Employee> emp = employeeService.getEmployee(1L);

    if (emp.isPresent()) {
        Employee employe = emp.get();
        System.out.println(employe.getFirstName());
        return employe;
    } else {
        System.out.println("ABSENT");
        // return an appropriate response indicating that the employee was not found
        return null;
    }
}

Regarding the issue with the Junit test class, it's difficult to determine the problem without more information, such as the exact error message or a code snippet of the test class.

Overall, the code needs to be more robust in handling cases where the employee was not found, and the test class needs to be further investigated to determine the root cause of the issue.